jif.types.label

## Class PairLabel_c

- java.lang.Object
- - polyglot.types.TypeObject_c
  - - jif.types.Param_c
    - - jif.types.label.Label_c
      - - jif.types.label.PairLabel_c

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable, ActsForParam, Label, PairLabel, Param, polyglot.types.TypeObject, polyglot.util.Copy<polyglot.types.TypeObject>

      public class PairLabel_c
      extends Label_c
      implements PairLabel

  See Also:
    Serialized Form

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface polyglot.util.Copy

      `polyglot.util.Copy.Util`

  - ### Field Summary

    - ### Fields inherited from class jif.types.label.Label_c

      `description, toJava, variables`

    - ### Fields inherited from class polyglot.types.TypeObject_c

      `position, ts`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PairLabel_c(JifTypeSystem ts, ConfPolicy confPolicy, IntegPolicy integPolicy, polyglot.util.Position pos, LabelToJavaExpr trans)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.lang.String` | `componentString(java.util.Set<Label> printedLabels)` return a string s such that {s} is a label
    `ConfPolicy` | `confPolicy()`
    `ConfPolicy` | `confProjection()`
    `boolean` | `equalsImpl(polyglot.types.TypeObject o)`
    `int` | `hashCode()`
    `boolean` | `hasWritersToReaders()` Does the label contain any writersToReaders constructs?
    `IntegPolicy` | `integPolicy()`
    `IntegPolicy` | `integProjection()`
    `boolean` | `isBottom()` By default, a label is not Bottom
    `boolean` | `isCanonical()`
    `boolean` | `isComparable()` Is this label comparable to other labels?
    `boolean` | `isCovariant()` Is this label covariant?
    `protected boolean` | `isDisambiguatedImpl()` Check if the label is disambiguated, without recursing into child labels.
    `boolean` | `isEnumerable()` Are the components of this label enumerable?
    `boolean` | `isRuntimeRepresentable()`
    `boolean` | `isTop()` Is this label equivalent to top?
    `PathMap` | `labelCheck(JifContext A, LabelChecker lc)` Label check the label, which will determine how much information may be gained if the label is evaluated at runtime.
    `boolean` | `leq_(Label L, LabelEnv env, LabelEnv.SearchState state)` Implementation of leq, should only be called by JifTypeSystem
    `protected Label` | `simplifyImpl()`
    `Label` | `subst(LabelSubstitution substitution)`
    `java.util.List<polyglot.types.Type>` | `throwTypes(polyglot.types.TypeSystem ts)` If the label is runtime representable, when it is evaluated at runtime it may throw exceptions.
    `java.lang.String` | `toString(java.util.Set<Label> printedLabels)` return a string representation of the label.
    `java.lang.String` | `toString(java.util.Set<Label> printedLabels, boolean topLevel)`
    `protected void` | `updateContextForSecond(LabelChecker lc, JifContext A, PathMap Xfirst)` Utility method for updating the context for checking the second part of the pair.

    - ### Methods inherited from class jif.types.label.Label_c

      `componentString, copy, description, hasVariableComponents, hasVariables, isDisambiguated, isInvariant, normalize, setDescription, simplify, toJava, toJava, toString, variableComponents, variables`

    - ### Methods inherited from class jif.types.Param_c

      `typeSystem`

    - ### Methods inherited from class polyglot.types.TypeObject_c

      `equals, position`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

    - ### Methods inherited from interface jif.types.label.Label

      `componentString, copy, description, hasVariableComponents, hasVariables, isDisambiguated, isInvariant, normalize, setDescription, simplify, toJava, toString, variableComponents, variables`

    - ### Methods inherited from interface jif.types.ActsForParam

      `toJava`

    - ### Methods inherited from interface jif.types.Param

      `typeSystem`

    - ### Methods inherited from interface polyglot.types.TypeObject

      `position`

- - ### Constructor Detail

    - #### PairLabel_c

          public PairLabel_c(JifTypeSystem ts,
                             ConfPolicy confPolicy,
                             IntegPolicy integPolicy,
                             polyglot.util.Position pos,
                             LabelToJavaExpr trans)

  - ### Method Detail

    - #### confPolicy

          public ConfPolicy confPolicy()

      Specified by:
        `confPolicy` in interface `PairLabel`

    - #### integPolicy

          public IntegPolicy integPolicy()

      Specified by:
        `integPolicy` in interface `PairLabel`

    - #### isRuntimeRepresentable

          public boolean isRuntimeRepresentable()

      Specified by:
        `isRuntimeRepresentable` in interface `Label`
      Specified by:
        `isRuntimeRepresentable` in interface `Param`

    - #### isCovariant

          public boolean isCovariant()

      Description copied from interface: `Label`
      Is this label covariant?
      Specified by:
        `isCovariant` in interface `Label`

    - #### isComparable

          public boolean isComparable()

      Description copied from interface: `Label`
      Is this label comparable to other labels?

      For example, an UnknownLabel is not comparable to others, neither is a VarLabel. Most other labels are.

      Specified by:
        `isComparable` in interface `Label`

    - #### isCanonical

          public boolean isCanonical()

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

    - #### isEnumerable

          public boolean isEnumerable()

      Description copied from interface: `Label`
      Are the components of this label enumerable?

      For example, Singletons are enumerable, JoinLabels are enumerable, RuntimeLabel (the label of all runtime representable components) is not enumerable. NOTE: The components of a label are not neccessarily stuck together with a join operation. For example, the MeetLabel uses the meet operation between its components.

      Specified by:
        `isEnumerable` in interface `Label`

    - #### isDisambiguatedImpl

          protected boolean isDisambiguatedImpl()

      Description copied from class: `Label_c`
      Check if the label is disambiguated, without recursing into child labels.
      Specified by:
        `isDisambiguatedImpl` in class `Label_c`

    - #### isBottom

          public boolean isBottom()

      Description copied from class: `Label_c`
      By default, a label is not Bottom
      Specified by:
        `isBottom` in interface `Label`
      Overrides:
        `isBottom` in class `Label_c`

    - #### isTop

          public boolean isTop()

      Description copied from interface: `Label`
      Is this label equivalent to top?

      For example, a JoinLabel with two components, one of which is Top, would return true for this method.

      Specified by:
        `isTop` in interface `Label`
      Overrides:
        `isTop` in class `Label_c`

    - #### equalsImpl

          public boolean equalsImpl(polyglot.types.TypeObject o)

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

    - #### simplifyImpl

          protected Label simplifyImpl()

      Overrides:
        `simplifyImpl` in class `Label_c`

    - #### confProjection

          public ConfPolicy confProjection()

      Specified by:
        `confProjection` in interface `Label`
      Overrides:
        `confProjection` in class `Label_c`

    - #### integProjection

          public IntegPolicy integProjection()

      Specified by:
        `integProjection` in interface `Label`
      Overrides:
        `integProjection` in class `Label_c`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `polyglot.types.TypeObject_c`

    - #### toString

          public java.lang.String toString(java.util.Set<Label> printedLabels)

      Description copied from interface: `Label`
      return a string representation of the label.
      Specified by:
        `toString` in interface `Label`
      Overrides:
        `toString` in class `Label_c`
      Parameters:
        `printedLabels` - the set of labels for which auxiliary information should be omitted.

    - #### componentString

          public java.lang.String componentString(java.util.Set<Label> printedLabels)

      Description copied from interface: `Label`
      return a string s such that {s} is a label
      Specified by:
        `componentString` in interface `Label`
      Specified by:
        `componentString` in class `Label_c`
      Parameters:
        `printedLabels` - the set of labels for which auxiliary information should be omitted.

    - #### toString

          public java.lang.String toString(java.util.Set<Label> printedLabels,
                                           boolean topLevel)

    - #### leq_

          public boolean leq_(Label L,
                              LabelEnv env,
                              LabelEnv.SearchState state)

      Description copied from interface: `Label`
      Implementation of leq, should only be called by JifTypeSystem
      Specified by:
        `leq_` in interface `Label`
      Parameters:
        `L` - the label to determine if this label is leq to. This label always satisfies !this.equals(L)
        `env` - the label environment (including principal hierarchy). Will always be non-null.

    - #### subst

          public Label subst(LabelSubstitution substitution)
                      throws polyglot.types.SemanticException

      Specified by:
        `subst` in interface `ActsForParam`
      Specified by:
        `subst` in interface `Label`
      Overrides:
        `subst` in class `Label_c`
      Parameters:
        `substitution` - The `LabelSubstitution` to apply to this label
      Returns:
        the result of applying labelSubst to this label.
      Throws:
        `polyglot.types.SemanticException`

    - #### throwTypes

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

      Description copied from interface: `Label`
      If the label 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 label may produce. If the label cannot be evaluated at runtime, an empty list should be returned.
      Specified by:
        `throwTypes` in interface `Label`
      Overrides:
        `throwTypes` in class `Label_c`

    - #### hasWritersToReaders

          public boolean hasWritersToReaders()

      Description copied from interface: `Label`
      Does the label contain any writersToReaders constructs?
      Specified by:
        `hasWritersToReaders` in interface `Label`
      Overrides:
        `hasWritersToReaders` in class `Label_c`

    - #### labelCheck

          public PathMap labelCheck(JifContext A,
                                    LabelChecker lc)

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

            boolean{Alice:} secret = ...;
            final label{Alice:} lb = secret?new label{}:new label{Bob:};
            boolean{} leak = false;
            if ((*lb} <= new label{}) { // evaluation of lb reveals
                                     // information at level {Alice:}
               leak = true;
            }

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

    - #### updateContextForSecond

          protected void updateContextForSecond(LabelChecker lc,
                                                JifContext A,
                                                PathMap Xfirst)

      Utility method for updating the context for checking the second part of the pair. Useful for overriding in projects like Fabric.