Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## jif.types.principal
Class DynamicPrincipal_c

    java.lang.Object
      polyglot.ext.jl.types.TypeObject_c
          jif.types.principal.Principal_c
              jif.types.principal.DynamicPrincipal_c

All Implemented Interfaces:
  java.io.Serializable, java.lang.Cloneable, Param, DynamicPrincipal, Principal, polyglot.types.TypeObject, polyglot.util.Copy

    public class DynamicPrincipal_c

extends Principal_c
implements DynamicPrincipal

An implementation of the `DynamicPrincipal` interface.

See Also:
  Serialized Form

Field Summary

Fields inherited from class polyglot.ext.jl.types.TypeObject_c
`position, ts`

Constructor Summary
`DynamicPrincipal_c(AccessPath path, JifTypeSystem ts, polyglot.util.Position pos)`

Method Summary
`boolean` | `equalsImpl(polyglot.types.TypeObject o)`
`int` | `hashCode()`
`boolean` | `isCanonical()`
`boolean` | `isRuntimeRepresentable()`
`PathMap` | `labelCheck(JifContext A)` Label check the principal, which will determine how much information may be gained if the principal is evaluated at runtime.
`AccessPath` | `path()`
`Principal` | `subst(AccessPathRoot r, AccessPath e)`
`java.util.List` | `throwTypes(polyglot.types.TypeSystem ts)` If the principal is runtime representable, when it is evaluated at runtime it may throw exceptions.
`java.lang.String` | `toString()`

Methods inherited from class jif.types.principal.Principal_c
`subst, toJava`

Methods inherited from class polyglot.ext.jl.types.TypeObject_c
`copy, equals, position, typeSystem`

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Methods inherited from interface jif.types.principal.Principal
`subst, toJava`

Methods inherited from interface polyglot.types.TypeObject
`position, typeSystem`

Methods inherited from interface polyglot.util.Copy
`copy`

Constructor Detail

### DynamicPrincipal_c

    public DynamicPrincipal_c(AccessPath path,
                              JifTypeSystem ts,
                              polyglot.util.Position pos)

Method Detail

### path

    public AccessPath path()

  Specified by:
    `path` in interface `DynamicPrincipal`

### isRuntimeRepresentable

    public boolean isRuntimeRepresentable()

  Specified by:
    `isRuntimeRepresentable` in interface `Param`
  Specified by:
    `isRuntimeRepresentable` in class `Principal_c`

### isCanonical

    public boolean isCanonical()

  Specified by:
    `isCanonical` in interface `Param`
  Specified by:
    `isCanonical` in interface `polyglot.types.TypeObject`
  Specified by:
    `isCanonical` in class `Principal_c`

### toString

    public java.lang.String toString()

  Overrides:
    `toString` in class `java.lang.Object`

### equalsImpl

    public boolean equalsImpl(polyglot.types.TypeObject o)

  Specified by:
    `equalsImpl` in interface `polyglot.types.TypeObject`
  Specified by:
    `equalsImpl` in class `Principal_c`

### hashCode

    public int hashCode()

  Specified by:
    `hashCode` in class `Principal_c`

### throwTypes

    public java.util.List throwTypes(polyglot.types.TypeSystem ts)

  Description copied from interface: `Principal`
  If the principal is runtime representable, when it is evaluated at runtime it may throw exceptions. This method returns a list of the exceptions that the runtime evaluation of the principal may produce. If the principal cannot be evaluated at runtime, an empty list should be returned.

  Specified by:
    `throwTypes` in interface `Principal`
  Overrides:
    `throwTypes` in class `Principal_c`

### subst

    public Principal subst(AccessPathRoot r,
                           AccessPath e)

  Specified by:
    `subst` in interface `DynamicPrincipal`

### labelCheck

    public PathMap labelCheck(JifContext A)

  Description copied from interface: `Principal`
  Label check the principal, which will determine how much information may be gained if the principal is evaluated at runtime. For example, given the dynamic principal p, where p is a local variable, evaluation of this label at runtime will reveal as much information as the label of p. For example, the following code is illegal, as the runtime evaluation of the principal reveals too much information

       boolean{Alice:} secret = ...;
       final principal{Alice:} p = secret?Bob:Chuck;
       boolean{} leak = false;
       if (p actsfor Bob) { // evaluation of p reveals
                            // information at level {Alice:}
           leak = true;
              }

  Specified by:
    `labelCheck` in interface `Principal`
  Overrides:
    `labelCheck` in class `Principal_c`
  See Also:
    `Jif.labelCheck(LabelChecker)`, `Label.labelCheck(JifContext)`

Overview | Package | Class | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD