jif.types.label

## Class WritersToReadersLabel_c

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

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

      public class WritersToReadersLabel_c
      extends Label_c
      implements WritersToReadersLabel

  An implementation of the `DynamicLabel` interface.
  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
    `WritersToReadersLabel_c(Label label, JifTypeSystem ts, polyglot.util.Position pos)`

  - ### Method Summary

    All Methods Static 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
    `boolean` | `equalsImpl(polyglot.types.TypeObject o)`
    `int` | `hashCode()`
    `boolean` | `hasWritersToReaders()` Does the label contain any writersToReaders constructs?
    `IntegPolicy` | `integProjection()`
    `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()`
    `Label` | `label()` The nested label.
    `boolean` | `leq_(Label L, LabelEnv env, LabelEnv.SearchState state)` Implementation of leq, should only be called by JifTypeSystem
    `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.
    `Label` | `transform(LabelEnv env)` Apply this operator to the nested label.
    `protected static Label` | `transformImpl(Label label)`
    `protected static ConfPolicy` | `transformIntegToConf(IntegPolicy pol)`

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

      `componentString, confProjection, copy, description, hasVariableComponents, hasVariables, isBottom, isDisambiguated, isInvariant, isTop, labelCheck, normalize, setDescription, simplify, simplifyImpl, 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, confProjection, copy, description, hasVariableComponents, hasVariables, isBottom, isDisambiguated, isInvariant, isTop, labelCheck, 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

    - #### WritersToReadersLabel_c

          public WritersToReadersLabel_c(Label label,
                                         JifTypeSystem ts,
                                         polyglot.util.Position pos)

  - ### Method Detail

    - #### label

          public Label label()

      Description copied from interface: `WritersToReadersLabel`
      The nested label.
      Specified by:
        `label` in interface `WritersToReadersLabel`

    - #### 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`

    - #### 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`

    - #### 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`

    - #### integProjection

          public IntegPolicy integProjection()

      Specified by:
        `integProjection` in interface `Label`
      Overrides:
        `integProjection` 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`

    - #### 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.

    - #### 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.

    - #### 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`

    - #### 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`

    - #### 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`

    - #### transform

          public Label transform(LabelEnv env)

      Description copied from interface: `WritersToReadersLabel`
      Apply this operator to the nested label.
      Specified by:
        `transform` in interface `WritersToReadersLabel`

    - #### transformImpl

          protected static Label transformImpl(Label label)

    - #### transformIntegToConf

          protected static ConfPolicy transformIntegToConf(IntegPolicy pol)