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
`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
`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("<init>", "()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<GenericTypeVar>(); 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`