de.dhbwstuttgart.syntaxtree

## Class Class

- java.lang.Object
- - de.dhbwstuttgart.syntaxtree.SyntaxTreeNode
  - - de.dhbwstuttgart.syntaxtree.GTVDeclarationContext
    - - de.dhbwstuttgart.syntaxtree.ClassOrInterface

- All Implemented Interfaces:
    AClassOrInterface, IItemWithOffset, Generic, GenericTypeInsertable
  Direct Known Subclasses:
    BasicAssumptionClass, FunNInterface, Interface

      public class Class
      extends GTVDeclarationContext
      implements AClassOrInterface, IItemWithOffset, Generic, GenericTypeInsertable

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `private Block` | `class_block`
    `private Menge<Type>` | `containedTypes`
    `private Menge<Field>` | `fielddecl`
    `private GenericDeclarationList` | `genericClassParameters`
    `protected static Logger` | `inferencelog` Log4j - Loggerinstanzen
    `static boolean` | `isFirstLocalVarDecl`
    `protected Modifiers` | `modifiers`
    `protected java.lang.String` | `name`
    `private int` | `offset`
    `private java.util.Hashtable<java.lang.String,java.lang.String>` | `parahash`
    `private SyntaxTreeNode` | `parent`
    `protected UsedId` | `pkgName`
    `private Type` | `superClass`
    `UsedId` | `superclassid`
    `private Menge<Type>` | `superif`
    `private TypeAssumptions` | `typeAssumptions`
    `protected Logger` | `typinferenzLog`
    `private Menge<UsedId>` | `usedIdsToCheck`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `Class(java.lang.String name, ClassBody cb, Menge<Type> ct, UsedId superclass, Menge<Type> superif, Menge<Type> paralist, int offset)`
    `Class(java.lang.String name, int offset)`
    `Class(java.lang.String name2, Modifiers object, ClassBody classBody, Menge<Type> containedTypes2, Menge<Type> typeMenge, Menge<Type> paraMenge, int offset2)`
    `Class(java.lang.String name, Modifiers mod, ClassBody cb, Menge<Type> ct, Menge<UsedId> usedIdsToCheck, UsedId superclass, Menge<UsedId> superif, Menge<Type> paralist, int offset)`
    `Class(java.lang.String name, Modifiers mod, ClassBody cb, Menge<Type> ct, Type superclass, Menge<Type> Menge, Menge<? extends Type> paralist, int offset)` Konstruktor, der die Angabe aller Parameter ermoeglicht.
    `Class(java.lang.String name2, Modifiers modifiers2, ClassBody classBody, Menge<Type> containedTypes2, UsedId usedId, Menge<Type> typeMenge, Menge<Type> paraMenge, int offset2)`
    `Class(java.lang.String name, Modifiers mod, int offset)`
    `Class(java.lang.String name, RefType superClass, Modifiers mod, int offset)`
    `Class(java.lang.String name, RefType superClass, Modifiers modifiers, Menge<java.lang.String> supertypeGenPara)` Erstellt eine Klasse, welche nur fÃ¼r die Assumptions verwendet wird.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addField(Field i)`
    `boolean` | `does_Class_extend()`
    `boolean` | `equals(java.lang.Object obj)`
    `Block` | `get_class_block()`
    `java.util.Hashtable<java.lang.String,java.lang.String>` | `get_ParaHash()`
    `Menge<? extends Type>` | `get_ParaList()`
    `JavaClassName` | `get_Superclass_Name()`
    `short` | `getAccessFlags()` Liefert die AccessFlags fuer den Bytecode zurueck.
    `Menge<SyntaxTreeNode>` | `getChildren()`
    `Menge<Type>` | `getContainedTypes()`
    `java.lang.String` | `getDescription()` Eine Beschreibung/Name des SyntaxTree-Nodes
    `Menge<Field>` | `getFields()`
    `Menge<GenericTypeVar>` | `getGenericParameter()`
    `int` | `getGenericVarDeclarationOffset()`
    `java.lang.String` | `getGenericVarDeclarationString(java.lang.String genericVarDeclaration)`
    `Modifiers` | `getModifiers()`
    `JavaClassName` | `getName()`
    `int` | `getOffset()` Errechnet die Generischen Parameter der Klasse fÃ¼r diese Klasse.
    `UsedId` | `getPackageName()`
    `SyntaxTreeNode` | `getParent()`
    `private TypeAssumptions` | `getPrivateFieldAssumptions()` Ermittelt alle privaten Felder und Methoden der Klasse und Erstellt eine Assumption fÃ¼r diese.
    `TypeAssumptions` | `getPublicFieldAssumptions()` Ermittelt die Sichtbaren Felder und Methoden der Klasse.
    `java.lang.String` | `getSimpleName()` HOTI Liefert bei Klassen die fullyQualified angegeben wurden nur den schlussendlichen Bezeichner p.ex. de.dhbwstuttgart.typeinference.Menge => Menge
    `Type` | `getSuperClass()` Die Super Klasse dieser Klasse.
    `Menge<Type>` | `getSuperInterfaces()`
    `RefType` | `getType()` Erstellt einen RefType, welcher auf diese Klasse verweist Ersetzt alle Generischen Variablen in der Parameterliste mit TPH
    `java.lang.String` | `getTypeInformation(Menge<Method> methodList, Menge<Expr> fieldList)`
    `Menge<UsedId>` | `getUsedIdsToCheck()`
    `int` | `getVariableLength()`
    `boolean` | `isClass()`
    `void` | `parserPostProcessing(SyntaxTreeNode parent)` Wird nach dem Parsen aufgerufen.
    `java.lang.String` | `printJavaCode(TypeinferenceResultSet reconstructionResult)` Generiert den JavaCode dieser Klasse im Falle fÃ¼r das Ã¼bergebene resultSet.
    `void` | `set_class_block(Block block)`
    `void` | `set_ClassBody(ClassBody body)` Setzt den ClassBody dieser Klasse.
    `void` | `set_ParaHash(java.util.Hashtable<java.lang.String,java.lang.String> hash)`
    `void` | `set_UsedId(UsedId uid)` Generiert die ClassFile fÃ¼r diese Klasse.
    `void` | `setContainedTypes(Menge<Type> containedTypes)`
    `void` | `setGenericParameter(GenericDeclarationList params)`
    `void` | `setModifiers(Modifiers mod)`
    `void` | `setName(java.lang.String strName)`
    `void` | `setPackageName(UsedId pkgName)`
    `void` | `setSuperInterfaces(Menge<Type> superif)`
    `java.lang.String` | `toString()` Author: Martin PlÃ¯Â¿Â½micke
    `ConstraintsSet` | `typeReconstruction(FC_TTO supportData, TypeAssumptions globalAssumptions)` Ausgangspunkt fÃ¯Â¿Â½r den Typrekonstruktionsalgorithmus.
    `private static Menge<Type>` | `usedIdToRefType(Menge<UsedId> superif2)`
    `private static Type` | `usedIdToRefType(UsedId superclass2)`
    `void` | `wandleRefTypeAttributes2GenericAttributes()` Alle Methoden der Klassen Ã¼berprÃ¼fen, ob sie als RefType deklarierte Attribute haben, die aber GenericTypeVars sind und ggf. ersetzen Bsp.: bei public E elementAt(i){...} wird E vorerst als RefType erkannt

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

      `getGTVDeclarationContext`

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

      `addTypeInsertPoints, getMatchingParentNode, getParentClass, seesType`

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

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

- - ### Field Detail

    - #### inferencelog

          protected static Logger inferencelog

      Log4j - Loggerinstanzen

    - #### pkgName

          protected UsedId pkgName

    - #### modifiers

          protected Modifiers modifiers

    - #### name

          protected java.lang.String name

    - #### superif

          private Menge<Type> superif

    - #### superclassid

          public UsedId superclassid

    - #### class_block

          private Block class_block

    - #### parahash

          private java.util.Hashtable<java.lang.String,java.lang.String> parahash

    - #### isFirstLocalVarDecl

          public static boolean isFirstLocalVarDecl

    - #### containedTypes

          private Menge<Type> containedTypes

    - #### usedIdsToCheck

          private Menge<UsedId> usedIdsToCheck

    - #### typeAssumptions

          private TypeAssumptions typeAssumptions

    - #### typinferenzLog

          protected Logger typinferenzLog

    - #### parent

          private SyntaxTreeNode parent

    - #### fielddecl

          private Menge<Field> fielddecl

    - #### genericClassParameters

          private GenericDeclarationList genericClassParameters

    - #### offset

          private int offset

    - #### superClass

          private Type superClass

  - ### Constructor Detail

    - #### Class

          public Class(java.lang.String name,
                       int offset)

    - #### Class

          public Class(java.lang.String name,
                       RefType superClass,
                       Modifiers modifiers,
                       Menge<java.lang.String> supertypeGenPara)

      Erstellt eine Klasse, welche nur fÃ¼r die Assumptions verwendet wird. Sie enthÃ¤lt keine unnÃ¶tigen Informationen, wie Offset oder ClassBody.
      Parameters:
        `name` -
        `superClass` -
        `modifiers` -
        `supertypeGenPara` - - Eine Liste von Namen, welche die Generischen Parameter der Klasse darstellen.

    - #### Class

          public Class(java.lang.String name,
                       RefType superClass,
                       Modifiers mod,
                       int offset)

    - #### Class

          public Class(java.lang.String name,
                       Modifiers mod,
                       int offset)

    - #### Class

          public Class(java.lang.String name,
                       Modifiers mod,
                       ClassBody cb,
                       Menge<Type> ct,
                       Menge<UsedId> usedIdsToCheck,
                       UsedId superclass,
                       Menge<UsedId> superif,
                       Menge<Type> paralist,
                       int offset)

    - #### Class

          public Class(java.lang.String name,
                       ClassBody cb,
                       Menge<Type> ct,
                       UsedId superclass,
                       Menge<Type> superif,
                       Menge<Type> paralist,
                       int offset)

    - #### Class

          public Class(java.lang.String name2,
                       Modifiers modifiers2,
                       ClassBody classBody,
                       Menge<Type> containedTypes2,
                       UsedId usedId,
                       Menge<Type> typeMenge,
                       Menge<Type> paraMenge,
                       int offset2)

    - #### Class

          public Class(java.lang.String name2,
                       Modifiers object,
                       ClassBody classBody,
                       Menge<Type> containedTypes2,
                       Menge<Type> typeMenge,
                       Menge<Type> paraMenge,
                       int offset2)

    - #### Class

          public Class(java.lang.String name,
                       Modifiers mod,
                       ClassBody cb,
                       Menge<Type> ct,
                       Type superclass,
                       Menge<Type> Menge,
                       Menge<? extends Type> paralist,
                       int offset)

      Konstruktor, der die Angabe aller Parameter ermoeglicht. Zur Uebersichtlichkeit in der Grammatik.

  - ### Method Detail

    - #### getPackageName

          public UsedId getPackageName()

    - #### setPackageName

          public void setPackageName(UsedId pkgName)

    - #### getName

          public JavaClassName getName()

      Specified by:
        `getName` in interface `AClassOrInterface`

    - #### setName

          public void setName(java.lang.String strName)

    - #### setModifiers

          public void setModifiers(Modifiers mod)

    - #### getModifiers

          public Modifiers getModifiers()

    - #### getAccessFlags

          public short getAccessFlags()

      Liefert die AccessFlags fuer den Bytecode zurueck.

    - #### getSuperInterfaces

          public Menge<Type> getSuperInterfaces()

      Specified by:
        `getSuperInterfaces` in interface `AClassOrInterface`

    - #### setSuperInterfaces

          public void setSuperInterfaces(Menge<Type> superif)

      Specified by:
        `setSuperInterfaces` in interface `AClassOrInterface`

    - #### usedIdToRefType

          private static Menge<Type> usedIdToRefType(Menge<UsedId> superif2)

    - #### usedIdToRefType

          private static Type usedIdToRefType(UsedId superclass2)

    - #### getFields

          public Menge<Field> getFields()

    - #### addField

          public void addField(Field i)

      Parameters:
        `feld` -

    - #### getUsedIdsToCheck

          public Menge<UsedId> getUsedIdsToCheck()

    - #### setContainedTypes

          public void setContainedTypes(Menge<Type> containedTypes)

    - #### getContainedTypes

          public Menge<Type> getContainedTypes()

    - #### set_UsedId

          public void set_UsedId(UsedId uid)

      Generiert die ClassFile fÃ¼r diese Klasse.
      Parameters:
        `typeinferenceResult` - - Das ResultSet einer Typinferierung oder null, falls alle Typen eindeutig feststehen.
      Throws:
        `JVMCodeException` - // ino.method.codegen.23071.definition public ClassFile codegen(ResultSet typeinferenceResult) throws JVMCodeException // ino.end // ino.method.codegen.23071.body { ClassFile classfile = new ClassFile(); String superClass; // Handling der Superklasse if(superclassid != null) { superClass = superclassid.get_codegen_UsedId(); } else { superClass = "java/lang/Object"; } // Handling der Package //String pkgName = ""; //if (sf.getPackageName() != null) { // pkgName = sf.getPackageName().get_codegen_UsedId() + "/"; //} //geÃ¤ndert von Andreas Stadelmeier: pkgName wird nicht mehr aus dem SourceFile ausgelesen: String packageName = ""; if(pkgName != null) packageName = pkgName.get_Name_1Element(); classfile.add_class(getName(), superClass, getAccessFlags()); // Handling fuer Superinterfaces classfile.addSuperInterfaces(getSuperInterfaces()); // Generics hinzufuegen - falls erforderlich classfile.addGenerics(this.paralist,superclassid, this.getSuperInterfaces()); // Body der Classfile generieren //if(body != null) { this.codegen(classfile, this.paralist); //} // Ueberpruefung, ob Konstruktor generiert // Falls nicht, default-Konstruktor erzeugen if(!classfile.get_constructor_founded()) { classfile.add_method("", "()V", null, null, null, (short)0, this.paralist, false); } //classfile.codegen(); codegenlog.info("Compilierung erfolgreich abgeschlossen, "+ getName() + ".class erstellt."); return classfile; }

    - #### set_ClassBody

          public void set_ClassBody(ClassBody body)

      Setzt den ClassBody dieser Klasse. Wird zum Parsen benÃ¶tigt. Der ClassBody enthÃ¤lt sÃ¤mtliche Felder dieser Klasse. Mit dem Aufruf dieser Methode werden alle Felder des ClassBody in diese Class Ã¼bertragen. (Nur einmal wÃ¤hrend des Parsens aufrufen!)

    - #### set_class_block

          public void set_class_block(Block block)

    - #### get_Superclass_Name

          public JavaClassName get_Superclass_Name()

    - #### get_class_block

          public Block get_class_block()

    - #### does_Class_extend

          public boolean does_Class_extend()

    - #### get_ParaList

          public Menge<? extends Type> get_ParaList()

    - #### set_ParaHash

          public void set_ParaHash(java.util.Hashtable<java.lang.String,java.lang.String> hash)

    - #### get_ParaHash

          public java.util.Hashtable<java.lang.String,java.lang.String> get_ParaHash()

    - #### typeReconstruction

          public ConstraintsSet typeReconstruction(FC_TTO supportData,
                                                   TypeAssumptions globalAssumptions)

      Ausgangspunkt fÃ¯Â¿Â½r den Typrekonstruktionsalgorithmus. Hier werden zunÃ¯Â¿Â½chst die Mengen von Typannahmen V_fields_methods und V_i erstellt, die als Eingabe fÃ¯Â¿Â½r den Algorithmus dienen.
      (siehe Algorithmus 5.17 TRProg, Martin PlÃ¯Â¿Â½micke)
      Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
      Parameters:
        `supportData` -
        `globalAssumptions` -
      Returns:
        Liste aller bisher berechneten, mÃ¯Â¿Â½glichen Typkombinationen
      Throws:
        `CTypeReconstructionException`

    - #### getPrivateFieldAssumptions

          private TypeAssumptions getPrivateFieldAssumptions()

      Ermittelt alle privaten Felder und Methoden der Klasse und Erstellt eine Assumption fÃ¼r diese. Bemerkung: Momentan werden noch alle Felder dieser Klasse zurÃ¼ckgegeben.
      Returns:
        Die erstellten TypeAssumptions

    - #### toString

          public java.lang.String toString()

      Author: Martin PlÃ¯Â¿Â½micke
      Overrides:
        `toString` in class `java.lang.Object`
      Returns:

    - #### wandleRefTypeAttributes2GenericAttributes

          public void wandleRefTypeAttributes2GenericAttributes()

      Alle Methoden der Klassen Ã¼berprÃ¼fen, ob sie als RefType deklarierte Attribute haben, die aber GenericTypeVars sind und ggf. ersetzen Bsp.: bei public E elementAt(i){...} wird E vorerst als RefType erkannt

    - #### getSimpleName

          public java.lang.String getSimpleName()

      HOTI Liefert bei Klassen die fullyQualified angegeben wurden nur den schlussendlichen Bezeichner p.ex. de.dhbwstuttgart.typeinference.Menge => Menge
      Returns:

    - #### getTypeInformation

          public java.lang.String getTypeInformation(Menge<Method> methodList,
                                                     Menge<Expr> fieldList)

    - #### printJavaCode

          public java.lang.String printJavaCode(TypeinferenceResultSet reconstructionResult)

      Generiert den JavaCode dieser Klasse im Falle fÃ¼r das Ã¼bergebene resultSet. Dem ResultSet entsprechend werden in diesem Java-Code die TypePlaceholder durch die in ResultSet stehenden Typen ersetzt.
      Returns:
        Java-Sourcefile

    - #### getOffset

          public int getOffset()

      Errechnet die Generischen Parameter der Klasse fÃ¼r diese Klasse. Die berechneten Variablen werden anschlieÃend in die this.genericTypeVars eingesetzt. Dabei werden alte genericTypeVars Ã¼berschrieben.
      Specified by:
        `getOffset` in interface `IItemWithOffset`
      Parameters:
        `reconstructionResult` - public void createGenericTypeVars(TypeinferenceResultSet reconstructionResult){ this.genericClassParameters = new Menge(); for(Pair pair : reconstructionResult.getUnifiedConstraints()){ if(pair.TA2 instanceof TypePlaceholder && pair.TA1 instanceof TypePlaceholder){// if(pair.OperatorSmallerExtends() || pair.OperatorSmaller()){ Type ta1=reconstructionResult.getUnifiedConstraints().getTypeEqualTo(pair.TA1); Type ta2=reconstructionResult.getUnifiedConstraints().getTypeEqualTo(pair.TA2); this.genericClassParameters.add(new GenericTypeVar(new Pair(ta1,ta2),this.getOffset())); } } for(Pair pair : reconstructionResult.getConstraints()){ if( ! reconstructionResult.getUnifiedConstraints().contains(pair.TA1)){ this.genericClassParameters.add(new GenericTypeVar(pair.TA1,this.getOffset())); } if( ! reconstructionResult.getUnifiedConstraints().contains(pair.TA2)){ this.genericClassParameters.add(new GenericTypeVar(pair.TA2, this.getOffset())); } } }

    - #### getType

          public RefType getType()

      Erstellt einen RefType, welcher auf diese Klasse verweist Ersetzt alle Generischen Variablen in der Parameterliste mit TPH
      Returns:

    - #### getPublicFieldAssumptions

          public TypeAssumptions getPublicFieldAssumptions()

      Ermittelt die Sichtbaren Felder und Methoden der Klasse. (Momentan sind im Projekt alle Felder und Methoden "package private", da der Parser keine Access-Modifier einlesen kann.
      Returns:

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

    - #### getParent

          public SyntaxTreeNode getParent()

      Overrides:
        `getParent` in class `SyntaxTreeNode`

    - #### getChildren

          public Menge<SyntaxTreeNode> getChildren()

      Specified by:
        `getChildren` in class `SyntaxTreeNode`

    - #### equals

          public boolean equals(java.lang.Object obj)

      Overrides:
        `equals` in class `SyntaxTreeNode`

    - #### getGenericParameter

          public Menge<GenericTypeVar> getGenericParameter()

      Specified by:
        `getGenericParameter` in interface `Generic`

    - #### getDescription

          public java.lang.String getDescription()

      Description copied from class: `SyntaxTreeNode`
      Eine Beschreibung/Name des SyntaxTree-Nodes
      Overrides:
        `getDescription` in class `SyntaxTreeNode`
      Returns:

    - #### getVariableLength

          public int getVariableLength()

      Specified by:
        `getVariableLength` in interface `IItemWithOffset`

    - #### setGenericParameter

          public void setGenericParameter(GenericDeclarationList params)

      Specified by:
        `setGenericParameter` in interface `Generic`

    - #### getGenericVarDeclarationString

          public java.lang.String getGenericVarDeclarationString(java.lang.String genericVarDeclaration)

      Specified by:
        `getGenericVarDeclarationString` in interface `GenericTypeInsertable`

    - #### getGenericVarDeclarationOffset

          public int getGenericVarDeclarationOffset()

      Specified by:
        `getGenericVarDeclarationOffset` in interface `GenericTypeInsertable`

    - #### getSuperClass

          public Type getSuperClass()

      Die Super Klasse dieser Klasse.
      Returns:
        null fÃ¼r Klasse Object

    - #### isClass

          public boolean isClass()

      Specified by:
        `isClass` in class `GTVDeclarationContext`