## Uses of Class
de.dhbwstuttgart.syntaxtree.SyntaxTreeNode

Packages that use SyntaxTreeNode
de.dhbwstuttgart.syntaxtree
de.dhbwstuttgart.syntaxtree.misc
de.dhbwstuttgart.syntaxtree.operator
de.dhbwstuttgart.syntaxtree.statement
de.dhbwstuttgart.syntaxtree.type
de.dhbwstuttgart.typeinference
de.dhbwstuttgart.typeinference.assumptions
de.dhbwstuttgart.exceptions
de.dhbwstuttgart.typeinference.typedeployment
syntaxTree

### Uses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree

Subclasses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree
`class` `BasicAssumptionClass`
`class` `Class`
`class` `Constant` Enthaelt die Eigenschaften einer Konstante (Name, Typ, Modifier, Wert)
`class` `Constructor`
`class` `Field`
`class` `FieldDeclaration` Eine Feldinitialisation steht fÃ¼r eine Felddeklaration mit gleichzeitiger Wertzuweisung Beispiel: 'public Feld FeldVar = FeldWert;'
`class` `FormalParameter`
`class` `GenericDeclarationList` Stellt eine Deklarations-Liste von Generischen Variablen dar.
`class` `GTVDeclarationContext` Beischreibt eine SyntaxTreeNode, welcher die Eigenschaft besitzt, dass bei seiner Deklaration auch Generische Typvariablen deklariert wurden.
`class` `Interface` Ein Interface ist eine abstrakte Klasse, erbt daher von Class
`class` `Method` Stellt eine Methode dar.
`class` `ParameterList`
`class` `SourceFile`

Fields in de.dhbwstuttgart.syntaxtree declared as SyntaxTreeNode
`private SyntaxTreeNode` Class.`parent`
`protected SyntaxTreeNode` SyntaxTreeNode.`parent`

Methods in de.dhbwstuttgart.syntaxtree that return SyntaxTreeNode
`SyntaxTreeNode` SyntaxTreeNode.`getMatchingParentNode(SyntaxTreeNode inNode)`
`SyntaxTreeNode` Class.`getParent()`
`SyntaxTreeNode` SyntaxTreeNode.`getParent()`
`SyntaxTreeNode` SourceFile.`getParent()`

Methods in de.dhbwstuttgart.syntaxtree that return types with arguments of type SyntaxTreeNode
`Menge<SyntaxTreeNode>` Class.`getChildren()`
`Menge<? extends SyntaxTreeNode>` ParameterList.`getChildren()`
`Menge<SyntaxTreeNode>` FieldDeclaration.`getChildren()`
`abstract Menge<? extends SyntaxTreeNode>` SyntaxTreeNode.`getChildren()`
`Menge<SyntaxTreeNode>` FormalParameter.`getChildren()`
`Menge<SyntaxTreeNode>` SourceFile.`getChildren()`
`Menge<SyntaxTreeNode>` Method.`getChildren()`
`Menge<SyntaxTreeNode>` Field.`getChildren()`
`Menge<SyntaxTreeNode>` GenericDeclarationList.`getChildren()`

Methods in de.dhbwstuttgart.syntaxtree with parameters of type SyntaxTreeNode
`SyntaxTreeNode` SyntaxTreeNode.`getMatchingParentNode(SyntaxTreeNode inNode)`
`void` Class.`parserPostProcessing(SyntaxTreeNode parent)`
`void` FieldDeclaration.`parserPostProcessing(SyntaxTreeNode parent)`
`void` SyntaxTreeNode.`parserPostProcessing(SyntaxTreeNode parent)` Wird nach dem Parsen aufgerufen.
`void` FormalParameter.`parserPostProcessing(SyntaxTreeNode parent)`
`void` SourceFile.`parserPostProcessing(SyntaxTreeNode parent)`
`void` Method.`parserPostProcessing(SyntaxTreeNode parent)`

### Uses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.misc

Subclasses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.misc
`class` `ConstructorCall` Diese Klasse stellt den this()-Aufruf dar.

### Uses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.operator

Subclasses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.operator
`class` `AddOp`
`class` `AndOp`
`class` `DivideOp`
`class` `EqualOp`
`class` `GreaterEquOp`
`class` `GreaterOp`
`class` `LessEquOp`
`class` `LessOp`
`class` `LogOp`
`class` `MinusOp`
`class` `ModuloOp`
`class` `MulOp`
`class` `NotEqualOp`
`class` `Operator`
`class` `OrOp`
`class` `PlusOp`
`class` `RelOp`
`class` `TimesOp`

Methods in de.dhbwstuttgart.syntaxtree.operator that return types with arguments of type SyntaxTreeNode
`Menge<SyntaxTreeNode>` Operator.`getChildren()`

### Uses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.statement

Subclasses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.statement
`class` `ArgumentList`
`class` `Assign`
`class` `Binary`
`class` `BinaryExpr`
`class` `Block`
`class` `BoolLiteral`
`class` `CastExpr`
`class` `CharLiteral`
`class` `DoubleLiteral`
`class` `EmptyStmt`
`class` `Expr`
`class` `ExprStmt`
`class` `FloatLiteral`
`class` `ForStmt`
`class` `IfStmt`
`class` `InstanceOf`
`class` `InstVar`
`class` `IntLiteral`
`class` `LambdaExpression`
`class` `LambdaParameter` Der FormalParameter einer LambdaExpression hat gesonderte Eigenschaften.
`class` `Literal`
`class` `LocalOrFieldVar`
`class` `LocalVarDecl`
`class` `LongLiteral`
`class` `MethodCall`
`class` `NegativeExpr`
`class` `NewArray`
`class` `NewClass`
`class` `NotExpr`
`class` `Null`
`class` `PositivExpr`
`class` `PostDecExpr`
`class` `PostIncExpr`
`class` `PreDecExpr`
`class` `PreIncExpr`
`class` `Return`
`class` `Statement`
`class` `StringLiteral`
`class` `SuperCall`
`class` `This`
`class` `ThisCall`
`class` `UnaryExpr`
`class` `WhileStmt`

Methods in de.dhbwstuttgart.syntaxtree.statement that return types with arguments of type SyntaxTreeNode
`Menge<SyntaxTreeNode>` NegativeExpr.`getChildren()`
`Menge<SyntaxTreeNode>` Assign.`getChildren()`
`Menge<SyntaxTreeNode>` IntLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` PositivExpr.`getChildren()`
`Menge<SyntaxTreeNode>` LambdaExpression.`getChildren()`
`Menge<? extends SyntaxTreeNode>` ArgumentList.`getChildren()`
`Menge<SyntaxTreeNode>` PreDecExpr.`getChildren()`
`Menge<SyntaxTreeNode>` LocalOrFieldVar.`getChildren()`
`Menge<SyntaxTreeNode>` DoubleLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` StringLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` Return.`getChildren()`
`Menge<SyntaxTreeNode>` CastExpr.`getChildren()`
`Menge<SyntaxTreeNode>` This.`getChildren()`
`Menge<SyntaxTreeNode>` MethodCall.`getChildren()`
`Menge<SyntaxTreeNode>` Binary.`getChildren()`
`Menge<SyntaxTreeNode>` InstVar.`getChildren()`
`Menge<SyntaxTreeNode>` Block.`getChildren()`
`Menge<SyntaxTreeNode>` NewArray.`getChildren()`
`Menge<SyntaxTreeNode>` PostDecExpr.`getChildren()`
`Menge<SyntaxTreeNode>` ForStmt.`getChildren()`
`Menge<SyntaxTreeNode>` NewClass.`getChildren()`
`Menge<SyntaxTreeNode>` Null.`getChildren()`
`Menge<SyntaxTreeNode>` BoolLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` CharLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` PreIncExpr.`getChildren()`
`Menge<SyntaxTreeNode>` IfStmt.`getChildren()`
`Menge<SyntaxTreeNode>` InstanceOf.`getChildren()`
`Menge<SyntaxTreeNode>` WhileStmt.`getChildren()`
`Menge<SyntaxTreeNode>` ThisCall.`getChildren()`
`Menge<SyntaxTreeNode>` EmptyStmt.`getChildren()`
`Menge<SyntaxTreeNode>` LongLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` LocalVarDecl.`getChildren()`
`Menge<SyntaxTreeNode>` FloatLiteral.`getChildren()`
`Menge<SyntaxTreeNode>` PostIncExpr.`getChildren()`
`Menge<SyntaxTreeNode>` NotExpr.`getChildren()`

Methods in de.dhbwstuttgart.syntaxtree.statement with parameters of type SyntaxTreeNode
`void` MethodCall.`parserPostProcessing(SyntaxTreeNode parent)`
`void` InstVar.`parserPostProcessing(SyntaxTreeNode parent)`
`void` LocalVarDecl.`parserPostProcessing(SyntaxTreeNode parent)`

Constructors in de.dhbwstuttgart.syntaxtree.statement with parameters of type SyntaxTreeNode
Constructor and Description
`SuperCall(SyntaxTreeNode parent)`
`This(SyntaxTreeNode parent)`
`ThisCall(SyntaxTreeNode parent)`

### Uses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.type

Subclasses of SyntaxTreeNode in de.dhbwstuttgart.syntaxtree.type
`class` `BaseType`
`class` `BooleanType`
`class` `BoundedGenericTypeVar` Entspricht einem GenericTypeVar, jedoch mit Bounds (d.h. vorgaben, von welchem Typ die Typevar sein darf => extends Class x => implements Interface y ...
`class` `CharacterType`
`class` `DoubleType`
`class` `ExtendsWildcardType` Stellt eine Wildcard mit oberer Grenze dar.
`class` `FloatType`
`class` `FreshExtendsWildcardType`
`class` `FreshSuperWildcardType`
`class` `FreshWildcardType`
`class` `GenericTypeVar` TODO: Diese Klasse Ã¼berarbeiten.
`class` `IntegerType`
`class` `LongType`
`class` `ObjectType`
`class` `RefType`
`class` `ReturnType`
`class` `SuperWildcardType` Stellt eine Wildcard mit unterer Grenze dar.
`class` `Type`
`class` `TypePlaceholder` ReprÃ¯Â¿Â½sentiert einen Typparameter fÃ¯Â¿Â½r einen vom Programmierer nicht angegeben Typ.
`class` `Void`
`class` `WildcardType` Stellt eine Wildcard in Java dar.

Fields in de.dhbwstuttgart.syntaxtree.type declared as SyntaxTreeNode
`private SyntaxTreeNode` TypePlaceholder.`parent`

Methods in de.dhbwstuttgart.syntaxtree.type that return types with arguments of type SyntaxTreeNode
`Menge<SyntaxTreeNode>` Type.`getChildren()`
`Menge<SyntaxTreeNode>` RefType.`getChildren()`
`Menge<SyntaxTreeNode>` BoundedGenericTypeVar.`getChildren()`

Methods in de.dhbwstuttgart.syntaxtree.type with parameters of type SyntaxTreeNode
`Type` Void.`checkTYPE(TypeAssumptions ass, SyntaxTreeNode method)`
`Type` Type.`checkTYPE(TypeAssumptions ass, SyntaxTreeNode method)`
`Type` RefType.`checkTYPE(TypeAssumptions ass, SyntaxTreeNode method)`
`static TypePlaceholder` TypePlaceholder.`fresh(java.lang.String name, SyntaxTreeNode parent)` Generiert einen neuen TPH mit einem bestimmten Namen.
`static TypePlaceholder` TypePlaceholder.`fresh(SyntaxTreeNode parent)`
`TypePlaceholder` GenericTypeVar.`getTypePlaceHolder(SyntaxTreeNode environment)`
`void` RefType.`GTV2TPH(SyntaxTreeNode environment)` Wandelt die Parameter des RefTypes in TPHs um, sofern es sich um Generische Variablen handelt.
`void` GenericTypeVar.`parserPostProcessing(SyntaxTreeNode parent)`
`void` ExtendsWildcardType.`parserPostProcessing(SyntaxTreeNode parent)`
`void` SuperWildcardType.`parserPostProcessing(SyntaxTreeNode parent)`
`void` RefType.`parserPostProcessing(SyntaxTreeNode parent)`
`ConstraintType` WildcardType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` GenericTypeVar.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` ExtendsWildcardType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` Void.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` TypePlaceholder.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` SuperWildcardType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` Type.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)` PrÃ¼ft ob der Typ in den Assumptions ass vorhanden ist.
`ConstraintType` BaseType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`
`ConstraintType` RefType.`TYPE(TypeAssumptions ass, SyntaxTreeNode parent)`

Constructors in de.dhbwstuttgart.syntaxtree.type with parameters of type SyntaxTreeNode
Constructor and Description
`BaseType(java.lang.String name, SyntaxTreeNode parent, int offset)`
`BaseType(SyntaxTreeNode parent, int offset)`
`BooleanType(SyntaxTreeNode parent)`
`BoundedGenericTypeVar(java.lang.String s, Menge<ObjectType> bounds, SyntaxTreeNode parentClass, int offset, int endOffset)`
`CharacterType(SyntaxTreeNode parent)`
`DoubleType(SyntaxTreeNode parent)`
`FloatType(SyntaxTreeNode parent)`
`FreshExtendsWildcardType(ObjectType extendsBound, SyntaxTreeNode parent, int offset)` Author: Arne LÃ¼dtke Standard Konstruktor fÃ¼r eine FreshExtendsWildcard
`FreshExtendsWildcardType(ObjectType extendsBound, SyntaxTreeNode parent, int offset, java.lang.String name)` Author: Arne LÃ¼dtke Privater Konstruktor fÃ¼r clone
`FreshSuperWildcardType(ObjectType superBound, SyntaxTreeNode parent, int offset)` Author: Arne LÃ¼dtke Standard Konstruktor fÃ¼r eine FreshSuperWildcard
`FreshSuperWildcardType(ObjectType superBound, SyntaxTreeNode parent, int offset, java.lang.String name)` Author: Arne LÃ¼dtke Privater Konstruktor fÃ¼r clone
`FreshWildcardType(SyntaxTreeNode parent, int offset)` Author: Arne LÃ¼dtke Standard Konstruktor fÃ¼r eine FreshWildcard
`FreshWildcardType(SyntaxTreeNode parent, int offset, java.lang.String name)` Author: Arne LÃ¼dtke Protected Konstruktor fÃ¼r clone.
`GenericTypeVar(java.lang.String s, SyntaxTreeNode parentClass, int offset)`
`IntegerType(SyntaxTreeNode parent)`
`LongType(SyntaxTreeNode parent)`
`ObjectType(java.lang.String s, SyntaxTreeNode parent, int offset)`
`ObjectType(SyntaxTreeNode parent, int offset)`
`RefType(JavaClassName jName, SyntaxTreeNode parent, int offset)`
`RefType(RefType R, SyntaxTreeNode parent, int offset)`
`RefType(java.lang.String fullyQualifiedName, Menge parameter, SyntaxTreeNode parent, int offset)`
`RefType(java.lang.String fullyQualifiedName, SyntaxTreeNode parent, int offset)`
`RefType(SyntaxTreeNode parent, int offset)`
`Type(java.lang.String s, SyntaxTreeNode parent, int offset)`
`Type(SyntaxTreeNode parent, int offset)`
`TypePlaceholder(java.lang.String typeName, SyntaxTreeNode parent)` Privater Konstruktor - Eine TypePlaceholder-Variable wird Ã¯Â¿Â½ber die Factory-Methode `fresh()` erzeugt.
`Void(SyntaxTreeNode parent, int offset)`
`WildcardType(ObjectType innerType, SyntaxTreeNode parent, int offset)` Author: Arne LÃ¼dtke Standard Konstruktor fÃ¼r eine Wildcard

### Uses of SyntaxTreeNode in de.dhbwstuttgart.typeinference

Subclasses of SyntaxTreeNode in de.dhbwstuttgart.typeinference
`class` `FunN`
`class` `FunNInterface` Stellt das Interface FunN dar.
`class` `FunNMethod`

### Uses of SyntaxTreeNode in de.dhbwstuttgart.typeinference.assumptions

Methods in de.dhbwstuttgart.typeinference.assumptions with parameters of type SyntaxTreeNode
`Type` TypeAssumptions.`checkType(RefType type, SyntaxTreeNode parent)`
`ConstraintType` TypeAssumptions.`getTypeFor(Type t, SyntaxTreeNode inNode)` Kontrolliert den vom Parser gesetzten Typ.

### Uses of SyntaxTreeNode in de.dhbwstuttgart.exceptions

Constructors in de.dhbwstuttgart.exceptions with parameters of type SyntaxTreeNode
Constructor and Description
`TypeinferenceException(java.lang.String message, SyntaxTreeNode problemSource)`

### Uses of SyntaxTreeNode in de.dhbwstuttgart.typeinference.typedeployment

Fields in de.dhbwstuttgart.typeinference.typedeployment declared as SyntaxTreeNode
`private SyntaxTreeNode` TypeInsertPoint.`node`

Methods in de.dhbwstuttgart.typeinference.typedeployment that return SyntaxTreeNode
`SyntaxTreeNode` TypeInsertPoint.`getInsertNode()`

Constructors in de.dhbwstuttgart.typeinference.typedeployment with parameters of type SyntaxTreeNode
Constructor and Description
`TypeInsertPoint(TypeInsertable insertPoint, SyntaxTreeNode insertNode, Type insertType, ResultSet resultSet)` Dieser Konstruktor erstellt einen TypInsertPoint

### Uses of SyntaxTreeNode in syntaxTree

Methods in syntaxTree with parameters of type SyntaxTreeNode
`private void` NodeEqualTest.`recursivlyCheckEqual(SyntaxTreeNode node1, SyntaxTreeNode node2)`