de.dhbwstuttgart.syntaxtree.type

## Class GenericTypeVar

- java.lang.Object
- - de.dhbwstuttgart.syntaxtree.SyntaxTreeNode
  - - de.dhbwstuttgart.syntaxtree.type.Type
    - - de.dhbwstuttgart.syntaxtree.type.ObjectType
      - - de.dhbwstuttgart.syntaxtree.type.GenericRefType

- All Implemented Interfaces:
    IItemWithOffset
  Direct Known Subclasses:
    BoundedGenericTypeVar

      public class GenericTypeVar
      extends ObjectType

  TODO: Diese Klasse Ã¼berarbeiten. Pair genericTypeVar ist nicht implementiert.
  Version:
    $Date: 2013/09/22 20:12:53 $
  Author:
    JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected Pair` | `genericConstraint`
    `private static java.util.HashMap<java.lang.String,TypePlaceholder>` | `tph` Eine Registry fÃ¯Â¿Â½r alle Generic-Instanzen, die vor der Bytecode-Generierung durch Ihre Superklasse ersetzt werden mÃ¯Â¿Â½ssen.

    - ### Fields inherited from class de.dhbwstuttgart.syntaxtree.type.Type

      `name, used`

    - ### Fields inherited from class de.dhbwstuttgart.syntaxtree.SyntaxTreeNode

      `parent`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `GenericTypeVar(java.lang.String s, SyntaxTreeNode parentClass, int offset)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `GenericTypeVar` | `clone()` Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
    `TypeAssumptions` | `createAssumptions()`
    `boolean` | `equals(java.lang.Object obj)` Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
    `java.lang.String` | `get_codegen_Type(Menge paralist)` hoti 4.5.06 Generische Typen werden im Bytecode aus Abwaertskompatiblitaet wie Object dargestellt
    `java.lang.String` | `get_Name()`
    `GTVDeclarationContext` | `getDeclarationContext()`
    `int` | `getEndOffset()`
    `JavaClassName` | `getName()`
    `java.lang.String` | `getSignatureType(Menge paralist)`
    `TypePlaceholder` | `getTypePlaceHolder(SyntaxTreeNode environment)`
    `int` | `hashCode()`
    `void` | `parserPostProcessing(SyntaxTreeNode parent)` Wird nach dem Parsen aufgerufen.
    `JavaCodeResult` | `printJavaCode(ResultSet resultSet)`
    `java.lang.String` | `toString()` Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
    `ConstraintsSet` | `TYPE(TypeAssumptions ass)` Die Type Methode auf generische Variablen angewandt sorgt fÃ¼r deren Eintragung in die TypeAssumptions.
    `ConstraintType` | `TYPE(TypeAssumptions ass, SyntaxTreeNode parent)` PrÃ¼ft ob der Typ in den Assumptions ass vorhanden ist.

    - ### Methods inherited from class de.dhbwstuttgart.syntaxtree.type.Type

      `applyResultSet, checkTYPE, get_UsedId, getChildren, getInvolvedTypePlaceholder, getOffset, getSimpleName, getSuperWildcardTypes, getUnresolvedTPH, getVariableLength, involves, set_UsedId, setOffset, Type2Key, Type2String`

    - ### Methods inherited from class de.dhbwstuttgart.syntaxtree.SyntaxTreeNode

      `addTypeInsertPoints, getDescription, getGTVDeclarationContext, getMatchingParentNode, getParent, getParentClass, seesType`

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

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

- - ### Field Detail

    - #### genericConstraint

          protected Pair genericConstraint

    - #### tph

          private static java.util.HashMap<java.lang.String,TypePlaceholder> tph

      Eine Registry fÃ¯Â¿Â½r alle Generic-Instanzen, die vor der Bytecode-Generierung durch Ihre Superklasse ersetzt werden mÃ¯Â¿Â½ssen. Siehe "Type Erasure" in Sun Spezifikation.
      Autor: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle

  - ### Constructor Detail

    - #### GenericTypeVar

          public GenericTypeVar(java.lang.String s,
                                SyntaxTreeNode parentClass,
                                int offset)

      Parameters:
        `genericTypeVarExtendsVar` - public GenericTypeVar(Pair genericTypeVarExtendsVar, int offset){ super(offset); genericTypeVar = genericTypeVarExtendsVar.TA1; if(genericTypeVarExtendsVar.TA2!=null)this.extendVars.add(genericTypeVarExtendsVar.TA2); else{ this.genericConstraint = genericTypeVarExtendsVar; } this.name = genericTypeVar.toString(); }

  - ### Method Detail

    - #### clone

          public GenericTypeVar clone()

      Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
      Specified by:
        `clone` in class `ObjectType`
      Returns:

    - #### equals

          public boolean equals(java.lang.Object obj)

      Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
      Overrides:
        `equals` in class `Type`
      Parameters:
        `obj` -
      Returns:

    - #### toString

          public java.lang.String toString()

      Description copied from class: `Type`
      Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
      Overrides:
        `toString` in class `Type`

    - #### hashCode

          public int hashCode()

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

    - #### get_codegen_Type

          public java.lang.String get_codegen_Type(Menge paralist)

      hoti 4.5.06 Generische Typen werden im Bytecode aus Abwaertskompatiblitaet wie Object dargestellt

    - #### getSignatureType

          public java.lang.String getSignatureType(Menge paralist)

    - #### printJavaCode

          public JavaCodeResult printJavaCode(ResultSet resultSet)

      Overrides:
        `printJavaCode` in class `Type`

    - #### getTypePlaceHolder

          public TypePlaceholder getTypePlaceHolder(SyntaxTreeNode environment)

    - #### get_Name

          public java.lang.String get_Name()

      Overrides:
        `get_Name` in class `Type`

    - #### getName

          public JavaClassName getName()

      Overrides:
        `getName` in class `Type`

    - #### createAssumptions

          public TypeAssumptions createAssumptions()

    - #### TYPE

          public ConstraintsSet TYPE(TypeAssumptions ass)

      Die Type Methode auf generische Variablen angewandt sorgt fÃ¼r deren Eintragung in die TypeAssumptions.
      Parameters:
        `ass` -
      Returns:

    - #### TYPE

          public ConstraintType TYPE(TypeAssumptions ass,
                                     SyntaxTreeNode parent)

      Description copied from class: `Type`
      PrÃ¼ft ob der Typ in den Assumptions ass vorhanden ist. Dabei kann eine neue Instanz eines Typs entstehen, welche von der Methode zurÃ¼ckgegeben wird.
      Overrides:
        `TYPE` in class `Type`
      Parameters:
        `ass` - - Die Assumptions fÃ¼r den jeweiligen Kontext in dem sich der Typ befindet. public ConstraintType checkType(TypeAssumptions ass, SyntaxTreeNode parent){ ConstraintType t = ass.getTypeFor(this, this); if(t==null) throw new TypeinferenceException("Der Typ "+this.getName()+" ist nicht korrekt", parent); return t; }

    - #### getEndOffset

          public int getEndOffset()

    - #### parserPostProcessing

          public void parserPostProcessing(SyntaxTreeNode parent)

      Description copied from class: `SyntaxTreeNode`
      Wird nach dem Parsen aufgerufen. ErfÃ¼llt folgenden Aufgaben: 1. FÃ¼llt fehlende Typangaben mit TPHs auf. 2. VerknÃ¼pft die Knoten des Syntaxbaums. (setzt Parent) 3. Wechselt RefTypes gegebenenfalls mit GenericTypeVars aus. 4. FÃ¼hrt einen Teil des Syntaxckecks durch.
      Overrides:
        `parserPostProcessing` in class `SyntaxTreeNode`

    - #### getDeclarationContext

          public GTVDeclarationContext getDeclarationContext()