## Uses of Class
de.dhbwstuttgart.typeinference.Menge

Packages that use Menge
de.dhbwstuttgart.core
de.dhbwstuttgart.JvmDisassembler
de.dhbwstuttgart.logger
de.dhbwstuttgart.myexception
de.dhbwstuttgart.parser
de.dhbwstuttgart.syntaxtree
de.dhbwstuttgart.syntaxtree.misc
de.dhbwstuttgart.syntaxtree.modifier
de.dhbwstuttgart.syntaxtree.operator
de.dhbwstuttgart.syntaxtree.statement
de.dhbwstuttgart.syntaxtree.type
de.dhbwstuttgart.typeinference
de.dhbwstuttgart.typeinference.assumptions
de.dhbwstuttgart.typeinference.typedeployment
de.dhbwstuttgart.typeinference.unify
KomplexeMenge
plugindevelopment.MartinTestCases
plugindevelopment.TypeInsertTests

### Uses of Menge in de.dhbwstuttgart.core

Fields in de.dhbwstuttgart.core declared as Menge
`private Menge<SourceFile>` MyCompiler.`m_AbstractSyntaxTree` Der abstrake Syntaxbaum Autor: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle
`Menge<Pair>` MyCompiler.`testPair`

Methods in de.dhbwstuttgart.core that return Menge
`Menge<Type>` AClassOrInterface.`getSuperInterfaces()`
`Menge<TypeinferenceResultSet>` MyCompiler.`typeReconstruction()` Author: JÃ¯Â¿Â½rg BÃ¯Â¿Â½uerle Ruft den Typrekonstruktionsalgorithmus auf.
`Menge<TypeinferenceResultSet>` MyCompilerAPI.`typeReconstruction()` Author: JÃ¶rg BÃ¤uerle Ruft den Typrekonstruktionsalgorithmus auf.

Methods in de.dhbwstuttgart.core with parameters of type Menge
`void` MyCompiler.`parse(Menge<java.lang.String> filenames)` Diese Funktion nimmt einen Menge von Dateinamen.
`void` MyCompilerAPI.`parse(Menge<java.lang.String> filenames)` Parst zusammenhÃ¤ngende JavaKlassen in verschiedenen Dateien.
`static void` ConsoleInterface.`run(Menge<java.lang.String> filenames)`
`void` AClassOrInterface.`setSuperInterfaces(Menge<Type> Menge)`

### Uses of Menge in de.dhbwstuttgart.JvmDisassembler

Methods in de.dhbwstuttgart.JvmDisassembler with parameters of type Menge
`(package private) static void` jvmDisassembler.`parse_attribute(java.io.DataInputStream d, Menge<java.lang.String> const_pool)`
`(package private) static void` jvmDisassembler.`parse_code(java.io.DataInputStream d, Menge<java.lang.String> const_pool)`

### Uses of Menge in de.dhbwstuttgart.logger

Fields in de.dhbwstuttgart.logger with type parameters of type Menge
`private java.util.HashMap<Section,Menge<java.io.PrintStream>>` LoggerConfiguration.`outputs`

### Uses of Menge in de.dhbwstuttgart.myexception

Fields in de.dhbwstuttgart.myexception declared as Menge
`private Menge<SCExcept>` SCClassException.`exlist`
`private Menge<SCExcept>` SCStatementException.`exlist`
`private Menge<SCExcept>` SCClassBodyException.`exlist`
`private Menge<SCExcept>` SCMethodException.`exlist`
`Menge<CTypeReconstructionException>` CTypeReconstructionException.`parentExceptions`
`private Menge<SCClassException>` SCException.`scerrors`

Methods in de.dhbwstuttgart.myexception that return Menge
`Menge<SCExcept>` SCStatementException.`get_exlist()`
`Menge<SCExcept>` SCClassBodyException.`get_exlist()`
`Menge<SCExcept>` SCMethodException.`get_exlist()`
`Menge<IItemWithOffset>` CTypeReconstructionException.`getHighestProblemSources()`

Methods in de.dhbwstuttgart.myexception with parameters of type Menge
`void` SCClassException.`addException(Menge<SCExcept> v)`
`void` SCMethodException.`set_exlist(Menge<SCExcept> list)`

Constructors in de.dhbwstuttgart.myexception with parameters of type Menge
Constructor and Description
`CTypeReconstructionException(java.lang.String message, Menge<CTypeReconstructionException> parentExceptions, IItemWithOffset problemSource)`

### Uses of Menge in de.dhbwstuttgart.parser

Subclasses of Menge in de.dhbwstuttgart.parser
`class` `BoundedClassIdentifierList`

Fields in de.dhbwstuttgart.parser declared as Menge
`private Menge<Type>` JavaParser.`containedTypes`
`private Menge<GenericTypeVar>` GenericVarDeclarationList.`elements`
`private Menge<ObjectType>` BoundedClassIdentifierList.`list`
`(package private) Menge<java.lang.String>` PackageName.`names`
`Menge` JavaParser.`path`
`private Menge<UsedId>` InterfaceList.`superif`
`Menge<Pair>` JavaParser.`testPair`
`private Menge<UsedId>` JavaParser.`usedIdsToCheck`

Methods in de.dhbwstuttgart.parser that return Menge
`Menge<GenericTypeVar>` GenericVarDeclarationList.`getElements()`
`Menge<Type>` InterfaceAndParameter.`getParaMenge()`
`Menge<Type>` ClassAndParameter.`getParaMenge()`
`Menge<Type>` InterfaceList.`getTypeMenge()`

Constructors in de.dhbwstuttgart.parser with parameters of type Menge
Constructor and Description
`BoundedClassIdentifierList(Menge<ObjectType> list, int endOffset)`
`PackageName(Menge<java.lang.String> packageNames)`

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

Subclasses of Menge in de.dhbwstuttgart.syntaxtree
`class` `ImportDeclarations` HOTI 4.5.06 Auch wenn es nicht so aussieht, hat diese Klasse einen Sinn :-) Der Parser kann keine Generischen Typen darstellen, damit trotzdem an amap Stellen die Typsicherheit gewÃ¤hrleistet ist, hier eine Kapselung...

Fields in de.dhbwstuttgart.syntaxtree declared as Menge
`protected Menge<Constant>` InterfaceBody.`ConstantVektor`
`private Menge<Type>` Class.`containedTypes`
`protected Menge<DeclId>` Field.`declid`
`private Menge<Field>` Class.`fielddecl`
`private Menge<Field>` ClassBody.`fielddecl`
`Menge<FormalParameter>` ParameterList.`formalparameter`
`private Menge<GenericTypeVar>` GenericDeclarationList.`gtvs`
`Menge<Interface>` SourceFile.`InterfaceVektor`
`Menge<Class>` SourceFile.`KlassenVektor`
`protected Menge<Method>` InterfaceBody.`MethodVektor`
`private Menge<RefType>` ExceptionList.`reftype`
`private Menge<Type>` Class.`superif`
`private Menge<java.lang.String>` Method.`types_in_parameterlist`
`private Menge<UsedId>` Class.`usedIdsToCheck`

Methods in de.dhbwstuttgart.syntaxtree that return Menge
`Menge<DeclId>` Field.`get_Name()`
`Menge<? extends Type>` Class.`get_ParaList()`
`Menge` Method.`get_Type_Paralist()`
`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()`
`Menge<Constant>` InterfaceBody.`getConstantVektor()`
`Menge<Type>` Class.`getContainedTypes()`
`Menge<DeclId>` Field.`getDeclIdMenge()`
`Menge<Field>` Class.`getFields()`
`Menge<Field>` ClassBody.`getFields()`
`Menge<GenericTypeVar>` Class.`getGenericParameter()`
`Menge<GenericTypeVar>` Field.`getGenericParameter()`
`Menge<GenericTypeVar>` GenericDeclarationList.`getMenge()`
`Menge<Method>` InterfaceBody.`getMethodVektor()`
`Menge` Interface.`getParaList()`
`Menge<Type>` Class.`getSuperInterfaces()`
`Menge<UsedId>` Class.`getUsedIdsToCheck()`
`Menge<FormalParameter>` ParameterList.`sc_get_Formalparalist()`
`Menge<TypeinferenceResultSet>` SourceFile.`typeReconstruction(TypeAssumptions globalAssumptions)` Tyrekonstruktionsalgorithmus: ruft fÃ¯Â¿Â½r jede Klasse den Algorithmus TRProg auf.
`private static Menge<Type>` Class.`usedIdToRefType(Menge<UsedId> superif2)`

Methods in de.dhbwstuttgart.syntaxtree with parameters of type Menge
`private void` GenericDeclarationList.`addAll(Menge<GenericTypeVar> values)`
`private boolean` SourceFile.`containsString(Menge<UsedId> searchMenge, java.lang.String searchString)`
`private Pair` SourceFile.`createPairFromClassAndSuperclass(Class baseClass, Type superclass, Menge classParaOrg, Menge superclassParaOrg, TypeAssumptions ass)` Erstellt ein Typ-Paar, welches im 1.
`private Pair` SourceFile.`createPairFromClassAndSuperclass(Class baseClass, Type superclass, Menge classParaOrg, Menge superclassParaOrg, TypeAssumptions ass)` Erstellt ein Typ-Paar, welches im 1.
`static GenericTypeVar` ClassHelper.`findGenericType(Type type, Menge<Type> paralist, Menge<GenericTypeVar> methodParaList)` Deprecated.
`static GenericTypeVar` ClassHelper.`findGenericType(Type type, Menge<Type> paralist, Menge<GenericTypeVar> methodParaList)` Deprecated.
`java.lang.String` Class.`getTypeInformation(Menge<Method> methodList, Menge<Expr> fieldList)`
`java.lang.String` Class.`getTypeInformation(Menge<Method> methodList, Menge<Expr> fieldList)`
`boolean` ClassBody.`is_declared(Type t, Menge<Class> classlist)`
`private TypeAssumptions` SourceFile.`makeBasicAssumptionsFromJRE(Menge<UsedId> imports, boolean withSubtypes)` Erstellt die Assumptions der standardmÃ¤Ãig importierten Packages (java.lang.) sowie der von imports Ã¼bergebenen Klassen zusammen.
`void` InterfaceBody.`setConstantVektor(Menge<Constant> constantVektor)`
`void` Class.`setContainedTypes(Menge<Type> containedTypes)`
`void` Field.`setDeclIdMenge(Menge<DeclId> vDeclId)`
`void` InterfaceBody.`setMethodVektor(Menge<Method> methodVektor)`
`void` Interface.`setParaList(Menge<Type> paraMenge)`
`void` Class.`setSuperInterfaces(Menge<Type> superif)`
`(package private) static java.lang.String` ClassBody.`string_rec(java.lang.String st, Menge v)`
`private static Menge<Type>` Class.`usedIdToRefType(Menge<UsedId> superif2)`
`void` FieldDeclaration.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist)`
`void` Method.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> classParalist)`
`void` Field.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist)` Wird im Zuge des ParserPostProcessing aufgerufen.

Constructors in de.dhbwstuttgart.syntaxtree with parameters of type Menge
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, ClassBody cb, Menge<Type> ct, UsedId superclass, Menge<Type> superif, Menge<Type> paralist, int offset)`
`Class(java.lang.String name, ClassBody cb, Menge<Type> ct, UsedId superclass, Menge<Type> superif, Menge<Type> paralist, 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 name2, Modifiers object, ClassBody classBody, Menge<Type> containedTypes2, Menge<Type> typeMenge, Menge<Type> paraMenge, int offset2)`
`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, 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, 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, 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 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 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 name2, Modifiers modifiers2, ClassBody classBody, Menge<Type> containedTypes2, UsedId usedId, Menge<Type> typeMenge, Menge<Type> paraMenge, int offset2)`
`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, RefType superClass, Modifiers modifiers, Menge<java.lang.String> supertypeGenPara)` Erstellt eine Klasse, welche nur fÃ¼r die Assumptions verwendet wird.
`GenericDeclarationList(Menge<GenericTypeVar> values, int endOffset)`
`SourceFile(Menge<Class> classDefinitions)`

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

Fields in de.dhbwstuttgart.syntaxtree.misc declared as Menge
`Menge<java.lang.String>` UsedId.`name`
`private Menge<Type>` UsedId.`paralist`
`Menge` DeclId.`paratyp`
`private Menge` UsedId.`typen`
`Menge<Type>` UsedId.`vParaOrg`

Methods in de.dhbwstuttgart.syntaxtree.misc that return Menge
`Menge` UsedId.`get_Name()`
`Menge<Type>` UsedId.`get_ParaList()`
`Menge` DeclId.`get_Paratyp()`
`Menge<Type>` UsedId.`get_RealParaList()`
`Menge` UsedId.`get_Typen()`
`Menge<Type>` UsedId.`get_vParaOrg()`

Methods in de.dhbwstuttgart.syntaxtree.misc with parameters of type Menge
`void` UsedId.`set_ParaList(Menge<Type> pl)`
`void` DeclId.`set_Paratyp(Menge p)`
`void` UsedId.`set_Typen(Menge t)`

### Uses of Menge in de.dhbwstuttgart.syntaxtree.modifier

Fields in de.dhbwstuttgart.syntaxtree.modifier declared as Menge
`protected Menge<Modifier>` Modifiers.`modifier`

Methods in de.dhbwstuttgart.syntaxtree.modifier that return Menge
`Menge<Modifier>` Modifiers.`getModifiers()`

Methods in de.dhbwstuttgart.syntaxtree.modifier with parameters of type Menge
`void` Modifiers.`setModifier(Menge<Modifier> modifier)`

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

Methods in de.dhbwstuttgart.syntaxtree.operator that return Menge
`Menge<SyntaxTreeNode>` Operator.`getChildren()`

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

Fields in de.dhbwstuttgart.syntaxtree.statement declared as Menge
`private Menge<DeclId>` LocalVarDecl.`declid`
`Menge<Expr>` ArgumentList.`expr`
`Menge<Expr>` NewArray.`expr`
`private Menge` LocalVarDecl.`paralist`
`Menge<Statement>` Block.`statements`

Methods in de.dhbwstuttgart.syntaxtree.statement that return Menge
`Menge` Expr.`get_Name_Menge()`
`Menge<Statement>` Block.`get_Statement()`
`Menge` Expr.`get_Type_Menge()`
`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()`
`Menge<DeclId>` LocalVarDecl.`getDeclidMenge()`
`private Menge<RefType>` UnaryExpr.`getNumericTypes()`

Methods in de.dhbwstuttgart.syntaxtree.statement with parameters of type Menge
`void` LocalVarDecl.`is_declared(Type t, Menge<Class> classlist)`
`(package private) void` ForStmt.`sc_check(Menge<Class> classname, java.util.Hashtable ch, java.util.Hashtable<java.lang.String,java.lang.String> bh, boolean ext, java.util.Hashtable parach, java.util.Hashtable<java.lang.String,java.util.Hashtable> parabh)`
`void` MethodCall.`set_Expr_Menge(Menge<Expr> v)`
`void` LocalVarDecl.`set_ParaList(Menge pl)`
`void` Block.`set_Statement_Menge(Menge<Statement> v)`
`void` LocalVarDecl.`setDeclidMenge(Menge<DeclId> declid)`
`void` NegativeExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` NegativeExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Assign.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Assign.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` IntLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` IntLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PositivExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PositivExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LambdaExpression.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LambdaExpression.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PreDecExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PreDecExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`abstract void` Statement.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`abstract void` Statement.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LocalOrFieldVar.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LocalOrFieldVar.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` DoubleLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` DoubleLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` StringLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` StringLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Return.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Return.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` CastExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` CastExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` This.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` This.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` MethodCall.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` MethodCall.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Binary.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Binary.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` InstVar.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` InstVar.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Block.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)` In allen lokalen Variablendeklarationen die "falschen" RefTypes ersetzen
`void` Block.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)` In allen lokalen Variablendeklarationen die "falschen" RefTypes ersetzen
`void` NewArray.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` NewArray.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PostDecExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PostDecExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` ForStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` ForStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` NewClass.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` NewClass.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Null.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` Null.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` BoolLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` BoolLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` CharLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` CharLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PreIncExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PreIncExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` IfStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` IfStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` InstanceOf.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` InstanceOf.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` WhileStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` WhileStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` EmptyStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` EmptyStmt.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LongLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LongLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LocalVarDecl.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` LocalVarDecl.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` FloatLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` FloatLiteral.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PostIncExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` PostIncExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` NotExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`
`void` NotExpr.`wandleRefTypeAttributes2GenericAttributes(Menge<Type> paralist, Menge<GenericTypeVar> genericMethodParameters)`

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

Subclasses of Menge in de.dhbwstuttgart.syntaxtree.type
`class` `ParaList`

Fields in de.dhbwstuttgart.syntaxtree.type declared as Menge
`(package private) Menge<ObjectType>` BoundedGenericTypeVar.`bounds` Hier sind die Bounds in Form von Type-Objekten abgespeichert
`private Menge<Type>` RefType.`parameter`
`private Menge<Type>` FreshWildcardType.`upperBounds`

Methods in de.dhbwstuttgart.syntaxtree.type that return Menge
`Menge<Type>` ParaList.`get_ParaList()`
`Menge<Type>` RefType.`get_ParaList()`
`Menge<Type>` FreshWildcardType.`get_UpperBounds()` Author: Arne LÃ¼dtke Gibt den Menge der oberen Grenzen zurÃ¼ck
`Menge<ObjectType>` BoundedGenericTypeVar.`getBounds()`
`Menge<SyntaxTreeNode>` Type.`getChildren()`
`Menge<SyntaxTreeNode>` RefType.`getChildren()`
`Menge<SyntaxTreeNode>` BoundedGenericTypeVar.`getChildren()`
`Menge<TypePlaceholder>` ExtendsWildcardType.`getInvolvedTypePlaceholder()`
`Menge<TypePlaceholder>` TypePlaceholder.`getInvolvedTypePlaceholder()`
`Menge<TypePlaceholder>` SuperWildcardType.`getInvolvedTypePlaceholder()`
`Menge<TypePlaceholder>` Type.`getInvolvedTypePlaceholder()` Sammelt alle TypePlaceholder, welche in diesem Typ vorkommen.
`Menge<TypePlaceholder>` RefType.`getInvolvedTypePlaceholder()`
`Menge<Type>` ParaList.`getParalist()`
`Menge<Type>` RefType.`getParaList()`
`Menge<TypeInsertPoint>` TypePlaceholder.`getTypeInsertPoints(ResultSet result)` Berechnet die InsertPoints dieses TypePlaceholders.
`Menge<TypePlaceholder>` TypePlaceholder.`getUnresolvedTPH(ResultSet resultSet)`
`Menge<TypePlaceholder>` Type.`getUnresolvedTPH(ResultSet resultSet)` Sucht nach TPHs in diesem Typ, denen das resultSet keinen Typ zuordnen kann.
`Menge<TypePlaceholder>` RefType.`getUnresolvedTPH(ResultSet resultSet)`

Methods in de.dhbwstuttgart.syntaxtree.type with parameters of type Menge
`GenericTypeVar` RefType.`findGenericType(Menge<Type> paralist, Menge<GenericTypeVar> methodParaList)` HOTI Diese Methode sucht in der Klassendefinition nach einen GTV, die so heiÃt wie die im RefType definierte Variable.
`GenericTypeVar` RefType.`findGenericType(Menge<Type> paralist, Menge<GenericTypeVar> methodParaList)` HOTI Diese Methode sucht in der Klassendefinition nach einen GTV, die so heiÃt wie die im RefType definierte Variable.
`java.lang.String` GenericTypeVar.`get_codegen_Type(Menge paralist)` hoti 4.5.06 Generische Typen werden im Bytecode aus Abwaertskompatiblitaet wie Object dargestellt
`java.lang.String` GenericTypeVar.`getSignatureType(Menge paralist)`
`void` RefType.`set_ParaList(Menge<Type> v)` FÃ¼gt eine Parameterliste an und tauscht zuvor alle GenerictTypeVars durch TPH aus.
`void` FreshWildcardType.`set_UpperBounds(Menge<Type> bounds)` Author: Arne LÃ¼dtke Setzt den Menge der oberen Grenzen
`void` ParaList.`setParalist(Menge<Type> paralist)`

Constructors in de.dhbwstuttgart.syntaxtree.type with parameters of type Menge
Constructor and Description
`BoundedGenericTypeVar(java.lang.String s, Menge<ObjectType> bounds, SyntaxTreeNode parentClass, int offset, int endOffset)`
`RefType(java.lang.String fullyQualifiedName, Menge parameter, SyntaxTreeNode parent, int offset)`

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

Fields in de.dhbwstuttgart.typeinference declared as Menge
`private Menge<Pair>` TypeinferenceResultSet.`constraints` Alle Constraints vor der Unifizierung.
`(package private) Menge<Pair>` ResultSet.`resultPairs`
`(package private) Menge<KomplexeMenge<A>>` OderMenge.`set`
`(package private) Menge<KomplexeMenge<A>>` UndMenge.`set`
`private Menge<Type>` FunN.`T`
`private Menge<TypePlaceholder>` JavaCodeResult.`unresolvedTPHs`

Methods in de.dhbwstuttgart.typeinference that return Menge
`static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1, Menge<Menge<M>> result)`
`Menge<Menge<A>>` KomplexeMenge.`cartesianProduct()`
`Menge<Menge<A>>` EinzelElement.`cartesianProduct()`
`Menge<Menge<A>>` OderMenge.`cartesianProduct()`
`Menge<Menge<A>>` UndMenge.`cartesianProduct()`
`private Menge<UndConstraint>` ConstraintsSet.`filterUndConstraints()` Aus dem ConstraintsSet [ u1, u2, ...
`Menge<UndMenge<A>>` KomplexeMenge.`getAndSets()`
`Menge<UndMenge<A>>` EinzelElement.`getAndSets()`
`Menge<UndMenge<A>>` OderMenge.`getAndSets()`
`Menge<UndMenge<A>>` UndMenge.`getAndSets()`
`Menge<Pair>` TypeinferenceResultSet.`getConstraints()`
`Menge<Pair>` ResultSet.`getConstraintsFor(Menge<TypePlaceholder> typePlaceholders)` Sammelt alle Constraints, welche mit den Ã¼bergebenen TPH's in Verbindung stehen.
`Menge<A>` KomplexeMenge.`getItems()`
`Menge<A>` EinzelElement.`getItems()`
`Menge<A>` OderMenge.`getItems()`
`Menge<A>` UndMenge.`getItems()`
`Menge<OderMenge<A>>` KomplexeMenge.`getOrSets()`
`Menge<OderMenge<A>>` EinzelElement.`getOrSets()`
`Menge<OderMenge<A>>` OderMenge.`getOrSets()`
`Menge<OderMenge<A>>` UndMenge.`getOrSets()`
`Menge<Pair>` ResultSet.`getResultSet()`
`Menge<TypePlaceholder>` Pair.`getTypePlaceholder()` Gibt eine Liste aller TypePlaceholder die in diesem Pair enthalten sind zurÃ¼ck.
`Menge<Type>` Pair.`getTypes()`
`Menge<Type>` ResultSet.`getTypesInvolving(Menge<TypePlaceholder> unresolvedTPH)` Durchsucht das ResultSet nach Typen, die die Ã¼bergebenen unresolvedTPHs als generische Variablen einbinden.
`Menge<TypePlaceholder>` JavaCodeResult.`getUnresolvedTPH()` Liefert alle TPHs, welche in diesem JavaCodeResult nicht zu einem Typ aufgelÃ¶st wurden.
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`karthesischesProdukt(Menge<M> m1, Menge<M> m2)`
`private static Menge<java.lang.String>` FunNInterface.`makeParaList(int n)`

Methods in de.dhbwstuttgart.typeinference that return types with arguments of type Menge
`static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1, Menge<Menge<M>> result)`
`Menge<Menge<A>>` KomplexeMenge.`cartesianProduct()`
`Menge<Menge<A>>` EinzelElement.`cartesianProduct()`
`Menge<Menge<A>>` OderMenge.`cartesianProduct()`
`Menge<Menge<A>>` UndMenge.`cartesianProduct()`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`karthesischesProdukt(Menge<M> m1, Menge<M> m2)`

Methods in de.dhbwstuttgart.typeinference with parameters of type Menge
`static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1, Menge<Menge<M>> result)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1, Menge<Menge<M>> result)`
`private int` ResultSet.`findPairWithTypeEqualTo(Type type, Menge<Pair> inResultPairs)`
`Menge<Pair>` ResultSet.`getConstraintsFor(Menge<TypePlaceholder> typePlaceholders)` Sammelt alle Constraints, welche mit den Ã¼bergebenen TPH's in Verbindung stehen.
`Menge<Type>` ResultSet.`getTypesInvolving(Menge<TypePlaceholder> unresolvedTPH)` Durchsucht das ResultSet nach Typen, die die Ã¼bergebenen unresolvedTPHs als generische Variablen einbinden.
`boolean` Pair.`isInMenge(Menge<Pair> V)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`karthesischesProdukt(Menge<M> m1, Menge<M> m2)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`karthesischesProdukt(Menge<M> m1, Menge<M> m2)`
`protected void` FunN.`setT(Menge<Type> T)`

Method parameters in de.dhbwstuttgart.typeinference with type arguments of type Menge
`static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1, Menge<Menge<M>> result)`
`private static <M> Menge<Menge<M>>` KarthesischesProdukt.`berechneKarthesischesProdukt(Menge<Menge<M>> m1, Menge<Menge<M>> result)`

Constructors in de.dhbwstuttgart.typeinference with parameters of type Menge
Constructor and Description
`FunN(Type R, Menge<Type> T)`
`FunNMethod(Menge<? extends Type> paralist)`
`ResultSet(Menge<Pair> resultSet)`
`TIPConstraints(Menge<TypePlaceholder> involvedTPHs)`
`TypeinferenceResultSet(Class inferedClass, Menge<Pair> constraints, ResultSet unifiedConstraints)`

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

Fields in de.dhbwstuttgart.typeinference.assumptions declared as Menge
`private Menge<ClassAssumption>` TypeAssumptions.`classAssumptions`
`private Menge<ConstructorAssumption>` TypeAssumptions.`constructorAssumptions`
`private Menge<FieldAssumption>` TypeAssumptions.`fieldAssumptions`
`private Menge<GenericVarAssumption>` TypeAssumptions.`genericVarAssumptions`
`private Menge<LocalVarAssumption>` TypeAssumptions.`localVarAssumptions`
`private Menge<MethodAssumption>` TypeAssumptions.`methodAssumptions`
`private Menge<ParameterAssumption>` TypeAssumptions.`parameterAssumptions`

Methods in de.dhbwstuttgart.typeinference.assumptions that return Menge
`private Menge<Assumption>` TypeAssumptions.`getAllAssumptions()`
`private Menge<FieldAssumption>` TypeAssumptions.`getAssumptionsFor(JavaClassName className)` Liefert alle Assumptions, auÃer die der lokalen Variablen, welche einer bestimmten Klasse zugeordnet sind.
`Menge<ClassAssumption>` TypeAssumptions.`getClassAssumptions()`
`Menge<FieldAssumption>` TypeAssumptions.`getFieldVars(java.lang.String withName)` Liefert alle bekannten Ã¶ffentlichen Feldern mit dem Namen withName.
`Menge<MethodAssumption>` TypeAssumptions.`getMethodAssumptions(JavaClassName className, java.lang.String methodName)` Sucht nach MethodAssumptions einer bestimmten Klasse mit einem bestimmten Namen.
`Menge<MethodAssumption>` TypeAssumptions.`getMethodAssumptions(java.lang.String methodName, int parameterCount)` Sucht nach Assumptions zu einer Methode mit dem Namen methodName und parameterCount Parametern.
`Menge<MethodAssumption>` TypeAssumptions.`getMethods2(java.lang.String withName)` Deprecated.

Methods in de.dhbwstuttgart.typeinference.assumptions with parameters of type Menge
`private void` TypeAssumptions.`addAllAssumptions(Menge<Assumption> assumptions)`

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

Fields in de.dhbwstuttgart.typeinference.typedeployment declared as Menge
`private Menge<GenericVarDeclarationPatch>` GenericVarPatch.`genericVarDeclarations`
`private Menge<GenericVarExtendsDeclarationPatch>` GenericVarPatch.`genericVarExtendDeclarations`
`private Menge<SourcePatchPoint>` TypePatchJob.`points`
`Menge<TypeInsertPoint>` TypeInsertSet.`points`
`private Menge<TypePlaceholder>` GenericVarPatch.`usedTPHs`

Methods in de.dhbwstuttgart.typeinference.typedeployment with parameters of type Menge
`void` TypeInsertSet.`add(Menge<TypeInsertPoint> insertPoints)` FÃ¼gt TypeInsertPoints an
`void` GenericVarPatch.`addPairs(Menge<Pair> pairs)`
`void` GenericVarPatch.`addTPHs(Menge<TypePlaceholder> TPHs)`
`private boolean` TypeInsertSet.`pairsDeclareTPH(Menge<Pair> ps, TypePlaceholder tph)`
`void` GenericVarPatch.`removeUnusedTPHs(Menge<TypePlaceholder> usedTPHs)`

### Uses of Menge in de.dhbwstuttgart.typeinference.unify

Fields in de.dhbwstuttgart.typeinference.unify declared as Menge
`(package private) Menge<Class>` FC_TTO.`CLASSVEC`
`(package private) Menge<Pair>` FC_TTO.`FC`
`private Menge<E>` CVectorSet.`m_Elements`
`(package private) Menge<? extends Type>` MUB.`Mub`
`(package private) Menge<Pair>` MUB.`generateGenerics`
`(package private) Menge` FC_TTO.`TTO`

Methods in de.dhbwstuttgart.typeinference.unify that return Menge
`static Menge<RefType>` Unify.`allGreater(RefType ty, Menge<Pair> FC)`
`static Menge<RefType>` Unify.`allSmaller(RefType ty, Menge<Pair> FC)`
`Menge<Menge<Pair>>` Unifier.`apply(Menge<Pair> E)`
`private static Menge<ObjectType>` Unify.`CaptureConversion(Menge<ObjectType> TVec, FC_TTO fc_tto)` Implementiert die CaptureConversion.
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec)` Ãberladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec)` Ãberladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
`static Menge<Menge<Pair>>` Unify.`copyMengeMengePair(Menge<Menge<Pair>> vp)`
`private static Menge<ObjectType>` Unify.`copyMengeObjectType(Menge<ObjectType> vec)` Kopiert einen Menge<ObjectType>.
`static Menge<Pair>` Unify.`copyMengePair(Menge<Pair> vp)`
`private static Menge<Type>` Unify.`copyMengeType(Menge<? extends Type> vec)` Kopiert einen Menge<Type>.
`private static Menge<Menge<Pair>>` Unify.`generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)` Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der Ã¼bergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
`Menge<Class>` FC_TTO.`getClasses()`
`Menge<Pair>` FC_TTO.`getFC()`
`Menge<E>` CVectorSet.`getMenge()`
`Menge<? extends Type>` MUB.`getMub()`
`Menge` FC_TTO.`getTTO()`
`Menge<Pair>` MUB.`getUnifier()`
`private static Menge<ObjectType>` Unify.`greater(ObjectType T, FC_TTO fc_tto)` Erzeugt alle Typen die greater sind als T.
`private static Menge<ObjectType>` Unify.`greater0(ObjectType T, FC_TTO fc_tto)` greater0 Schritt von greater.
`private static Menge<ObjectType>` Unify.`greater1(ObjectType T, FC_TTO fc_tto)` greater1 Schritt von greater.
`private static Menge<ObjectType>` Unify.`greater2(Menge<ObjectType> greater1Erg, FC_TTO fc_tto)` greater2 Schritt von greater
`private static Menge<ObjectType>` Unify.`greater3(Menge<ObjectType> greater2Erg, FC_TTO fc_tto)` greater3 Schritt von greater
`private static Menge<Type>` Unify.`greaterArg(Type T, FC_TTO fc_tto)` greaterArg Schritt von greater FÃ¼r den Argumenttype FunN<...> werden keine ?
`static Menge<Menge<Pair>>` Unify.`instanceSmaller(Pair P, FC_TTO fc_tto)`
`static Menge<Menge<java.lang.Integer>>` Unify.`schnitt(Menge<Menge<TypePlaceholder>> vars)` Bildet Schnittmengen der Mengen von Typeplaceholders Rueckgabe ist die Menge der Menge von Indizies die Schnittmengen sind.
`(package private) static Menge<java.lang.Integer>` Unify.`schnitt1(Menge<TypePlaceholder> var, Menge<Menge<TypePlaceholder>> vars, Menge<java.lang.Integer> indexe)` PL 2014-10-25 schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind RÃ¼ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
`private static Menge<ObjectType>` Unify.`smaller(ObjectType T, FC_TTO fc_tto)` Erzeugt alle Typen die smaller sind als T.
`private static Menge<ObjectType>` Unify.`smaller0(ObjectType T, FC_TTO fc_tto)` smaller0 Schritt von smaller
`private static Menge<ObjectType>` Unify.`smaller1(Type T, FC_TTO fc_tto)` smaller1 Schritt von smaller
`private static Menge<ObjectType>` Unify.`smaller2(Menge<ObjectType> smaller1Erg, FC_TTO fc_tto)` smaller2 Schritt von smaller
`private static Menge<ObjectType>` Unify.`smaller3(Menge<ObjectType> smaller12Erg, FC_TTO fc_tto)` smaller3 Schritt von smaller
`private static Menge<ObjectType>` Unify.`smaller4(Menge<ObjectType> smallerErg)` smaller4 Schritt von smaller
`private static Menge<Type>` Unify.`smallerArg(Type T, FC_TTO fc_tto)` smallerArg Schritt von smaller
`static Menge<Pair>` Unify.`sub_unify(Menge<Pair> E, FC_TTO fc_tto)`
`static Menge<Pair>` Unify.`sub_unify(Menge<Pair> E, FC_TTO fc_tto, boolean useSubst)`
`static Menge<Pair>` Unify.`SubstHashtable2MengePair(java.util.Hashtable<JavaClassName,Type> ht)`
`static Menge<Menge<Pair>>` Unify.`unify(Menge<Pair> E, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards
`static Menge<Menge<Pair>>` Unify.`unify(Type ty1, Type ty2, FC_TTO fc_tto)` Unifiziert ein Pair mit den Elementen ty1 und ty2 -> (ty1 < ty2)
`static Menge<Menge<Pair>>` Unify.`unifyFiltered(Menge<Pair> E, FC_TTO fc_tto, boolean filter)`
`static Menge<Menge<Pair>>` Unify.`unifyWC(Pair P, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards
`static Menge<Menge<Pair>>` Unify.`unifyWC(Type ty1, Type ty2, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards

Methods in de.dhbwstuttgart.typeinference.unify that return types with arguments of type Menge
`Menge<Menge<Pair>>` Unifier.`apply(Menge<Pair> E)`
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec)` Ãberladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec)` Ãberladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
`static Menge<Menge<Pair>>` Unify.`copyMengeMengePair(Menge<Menge<Pair>> vp)`
`private static Menge<Menge<Pair>>` Unify.`generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)` Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der Ã¼bergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
`static Menge<Menge<Pair>>` Unify.`instanceSmaller(Pair P, FC_TTO fc_tto)`
`static Menge<Menge<java.lang.Integer>>` Unify.`schnitt(Menge<Menge<TypePlaceholder>> vars)` Bildet Schnittmengen der Mengen von Typeplaceholders Rueckgabe ist die Menge der Menge von Indizies die Schnittmengen sind.
`static Menge<Menge<Pair>>` Unify.`unify(Menge<Pair> E, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards
`static Menge<Menge<Pair>>` Unify.`unify(Type ty1, Type ty2, FC_TTO fc_tto)` Unifiziert ein Pair mit den Elementen ty1 und ty2 -> (ty1 < ty2)
`static Menge<Menge<Pair>>` Unify.`unifyFiltered(Menge<Pair> E, FC_TTO fc_tto, boolean filter)`
`static Menge<Menge<Pair>>` Unify.`unifyWC(Pair P, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards
`static Menge<Menge<Pair>>` Unify.`unifyWC(Type ty1, Type ty2, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards

Methods in de.dhbwstuttgart.typeinference.unify with parameters of type Menge
`private static void` Unify.`adapt(Menge<Pair> H, Pair PFC, RefType TA1, RefType TA2, FC_TTO fc_tto)` Implementiert die adapt Regel des sub_unify
`private static void` Unify.`adaptExt(Menge<Pair> H, Pair PFC, RefType TA1, RefType TA2, FC_TTO fc_tto)` Implementiert die adaptExt Regel des sub_unify
`private static void` Unify.`adaptSup(Menge<Pair> H, Pair PFC, RefType TA1, RefType TA2, FC_TTO fc_tto)` Implementiert die adaptSup Regel des sub_unify
`static Menge<RefType>` Unify.`allGreater(RefType ty, Menge<Pair> FC)`
`static Menge<RefType>` Unify.`allSmaller(RefType ty, Menge<Pair> FC)`
`Menge<Menge<Pair>>` Unifier.`apply(Menge<Pair> E)`
`private static Menge<ObjectType>` Unify.`CaptureConversion(Menge<ObjectType> TVec, FC_TTO fc_tto)` Implementiert die CaptureConversion.
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec)` Ãberladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec)` Ãberladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
`static Menge<Menge<Pair>>` Unify.`copyMengeMengePair(Menge<Menge<Pair>> vp)`
`private static Menge<ObjectType>` Unify.`copyMengeObjectType(Menge<ObjectType> vec)` Kopiert einen Menge<ObjectType>.
`static Menge<Pair>` Unify.`copyMengePair(Menge<Pair> vp)`
`private static Menge<Type>` Unify.`copyMengeType(Menge<? extends Type> vec)` Kopiert einen Menge<Type>.
`private static Menge<Menge<Pair>>` Unify.`generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)` Diese Methode generiert einen Menge<Menge<Pair>> wobei immer der Ã¼bergebene TA1 vorne steht, und jeder Typ aus otherPairTypes hinten.
`private static Menge<ObjectType>` Unify.`greater2(Menge<ObjectType> greater1Erg, FC_TTO fc_tto)` greater2 Schritt von greater
`private static Menge<ObjectType>` Unify.`greater3(Menge<ObjectType> greater2Erg, FC_TTO fc_tto)` greater3 Schritt von greater
`static boolean` Unify.`hasSolvedForm(Menge<Pair> E)`
`static Pair` Unify.`isInFC(RefType R1, RefType R2, Menge<Pair> FC)`
`private static Pair` Unify.`isInFClinks(RefType RT1, RefType RT2, Menge<Pair> FC)`
`static java.util.Hashtable<JavaClassName,Type>` Unify.`MengePair2SubstHashtableMengePair(Menge<Pair> v)`
`private UnifyResult` ParallelUnify.`parallelUnify(Menge<Pair> pairs, FC_TTO fc)`
`static int` Unify.`pi(int n, java.lang.String C, java.lang.String D, Menge tto)`
`static void` Unify.`printMenge(java.lang.String strMenge, Menge<Pair> E, int nDebug)`
`static void` Unify.`printMengeUnifier(java.lang.String strMenge, Menge<Menge<Pair>> Uni, int nDebug)`
`private static void` Unify.`reduce1(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduce1 Regel des sub_unify
`private static void` Unify.`reduce1(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduce1 Regel des sub_unify
`private static void` Unify.`reduce2(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduce2 Regel des sub_unify
`private static void` Unify.`reduce2(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduce2 Regel des sub_unify
`private static void` Unify.`reduceEq(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduceEq Regel des sub_unify Da in reduce2 unnÃ¶tigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren.
`private static void` Unify.`reduceEq(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduceEq Regel des sub_unify Da in reduce2 unnÃ¶tigerweise pi verwendet wird (siehe Kommentar in reduce2), kann reduceEq einfach an reduce2 deligieren.
`private static void` Unify.`reduceExt(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduceExt Regel des sub_unify
`private static void` Unify.`reduceExt(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduceExt Regel des sub_unify
`private static void` Unify.`reduceSup(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduceSup Regel des sub_unify
`private static void` Unify.`reduceSup(Menge<Pair> H, RefType TA1, RefType TA2, Menge TTO)` Implementiert die reduceSup Regel des sub_unify
`static Menge<Menge<java.lang.Integer>>` Unify.`schnitt(Menge<Menge<TypePlaceholder>> vars)` Bildet Schnittmengen der Mengen von Typeplaceholders Rueckgabe ist die Menge der Menge von Indizies die Schnittmengen sind.
`(package private) static Menge<java.lang.Integer>` Unify.`schnitt1(Menge<TypePlaceholder> var, Menge<Menge<TypePlaceholder>> vars, Menge<java.lang.Integer> indexe)` PL 2014-10-25 schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind RÃ¼ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
`(package private) static Menge<java.lang.Integer>` Unify.`schnitt1(Menge<TypePlaceholder> var, Menge<Menge<TypePlaceholder>> vars, Menge<java.lang.Integer> indexe)` PL 2014-10-25 schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind RÃ¼ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
`(package private) static Menge<java.lang.Integer>` Unify.`schnitt1(Menge<TypePlaceholder> var, Menge<Menge<TypePlaceholder>> vars, Menge<java.lang.Integer> indexe)` PL 2014-10-25 schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind RÃ¼ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
`void` CVectorSet.`setMenge(Menge<E> elements)`
`private static Menge<ObjectType>` Unify.`smaller2(Menge<ObjectType> smaller1Erg, FC_TTO fc_tto)` smaller2 Schritt von smaller
`private static Menge<ObjectType>` Unify.`smaller3(Menge<ObjectType> smaller12Erg, FC_TTO fc_tto)` smaller3 Schritt von smaller
`private static Menge<ObjectType>` Unify.`smaller4(Menge<ObjectType> smallerErg)` smaller4 Schritt von smaller
`static Menge<Pair>` Unify.`sub_unify(Menge<Pair> E, FC_TTO fc_tto)`
`static Menge<Pair>` Unify.`sub_unify(Menge<Pair> E, FC_TTO fc_tto, boolean useSubst)`
`private static void` Unify.`testUnifyErg(Menge<Menge<Pair>> unifyErgs, RefType test)` Diese Methode wird verwendet, um Zuordnungen z.B.
`static Menge<Menge<Pair>>` Unify.`unify(Menge<Pair> E, FC_TTO fc_tto)` Einstieg in die Unifizierung mit Wildcards
`static Menge<Menge<Pair>>` Unify.`unifyFiltered(Menge<Pair> E, FC_TTO fc_tto, boolean filter)`

Method parameters in de.dhbwstuttgart.typeinference.unify with type arguments of type Menge
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec)` Ãberladung der Funktion cartProductPair, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Pair>>` Unify.`cartProductPair(Menge<Menge<Pair>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Paaren.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec)` Ãberladung der Funktion cartProductType, damit der Programmierer beim ersten Aufruf nicht den 2.
`private static Menge<Menge<Type>>` Unify.`cartProductType(Menge<Menge<Type>> vec, int index)` Erzeugt das Kartesische Product von mehreren Mengeen von Typen.
`static Menge<Menge<Pair>>` Unify.`copyMengeMengePair(Menge<Menge<Pair>> vp)`
`static void` Unify.`printMengeUnifier(java.lang.String strMenge, Menge<Menge<Pair>> Uni, int nDebug)`
`static Menge<Menge<java.lang.Integer>>` Unify.`schnitt(Menge<Menge<TypePlaceholder>> vars)` Bildet Schnittmengen der Mengen von Typeplaceholders Rueckgabe ist die Menge der Menge von Indizies die Schnittmengen sind.
`(package private) static Menge<java.lang.Integer>` Unify.`schnitt1(Menge<TypePlaceholder> var, Menge<Menge<TypePlaceholder>> vars, Menge<java.lang.Integer> indexe)` PL 2014-10-25 schnitt1 checkt ob die Typeplaceholders aus in den Elemeneten aus vars enthalten sind RÃ¼ckgabe ist die Menge der Indizies von vars der Schnittmengen mit var nicht leer sind.
`private static void` Unify.`testUnifyErg(Menge<Menge<Pair>> unifyErgs, RefType test)` Diese Methode wird verwendet, um Zuordnungen z.B.

Constructors in de.dhbwstuttgart.typeinference.unify with parameters of type Menge
Constructor and Description
`CSubstitutionSet(Menge<Pair> unifiers)`
`FC_TTO(Menge<Pair> fc, Menge tto, Menge<Class> classv)`
`FC_TTO(Menge<Pair> fc, Menge tto, Menge<Class> classv)`
`FC_TTO(Menge<Pair> fc, Menge tto, Menge<Class> classv)`
`MUB(Menge<? extends Type> M, Menge<Pair> s)`
`MUB(Menge<? extends Type> M, Menge<Pair> s)`

### Uses of Menge in KomplexeMenge

Methods in KomplexeMenge with parameters of type Menge
`private <A> void` KeineDoppeltenVerweise.`check(Menge<Menge<A>> cP)`
`private java.lang.Object` KeineDoppeltenVerweise.`containsRef(Menge v, java.lang.Object i)`

Method parameters in KomplexeMenge with type arguments of type Menge
`private <A> void` KeineDoppeltenVerweise.`check(Menge<Menge<A>> cP)`

### Uses of Menge in plugindevelopment.MartinTestCases

Methods in plugindevelopment.MartinTestCases with parameters of type Menge
`static void` Tester.`test(java.lang.String sourceFileToInfere, Menge<java.lang.String> mustContain)`

### Uses of Menge in plugindevelopment.TypeInsertTests

Methods in plugindevelopment.TypeInsertTests with parameters of type Menge
`static void` MultipleTypesInsertTester.`test(java.lang.String sourceFileToInfere, Menge<java.lang.String> mustContain)`
`static void` MultipleTypesInsertTester.`test(java.lang.String sourceFileToInfere, Menge<java.lang.String> mustContain, LoggerConfiguration additionalConfig)`
`static void` MultipleTypesInsertTester.`testSingleInsert(java.lang.String sourceFileToInfere, Menge<java.lang.String> mustContain)`