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

- Packages that use Menge
  Package | Description
  --- | ---
  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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `(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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Class and Description
    --- | ---
    `class` | `BoundedClassIdentifierList`

    Fields in de.dhbwstuttgart.parser declared as Menge
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Class and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `protected Menge<Modifier>` | Modifiers.`modifier`

    Methods in de.dhbwstuttgart.syntaxtree.modifier that return Menge
    Modifier and Type | Method and Description
    --- | ---
    `Menge<Modifier>` | Modifiers.`getModifiers()`

    Methods in de.dhbwstuttgart.syntaxtree.modifier with parameters of type Menge
    Modifier and Type | Method and Description
    --- | ---
    `void` | Modifiers.`setModifier(Menge<Modifier> modifier)`

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

    Methods in de.dhbwstuttgart.syntaxtree.operator that return Menge
    Modifier and Type | Method and Description
    --- | ---
    `Menge<SyntaxTreeNode>` | Operator.`getChildren()`

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

    Fields in de.dhbwstuttgart.syntaxtree.statement declared as Menge
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Class and Description
    --- | ---
    `class` | `ParaList`

    Fields in de.dhbwstuttgart.syntaxtree.type declared as Menge
    Modifier and Type | Field and Description
    --- | ---
    `(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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `private void` | TypeAssumptions.`addAllAssumptions(Menge<Assumption> assumptions)`

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

    Fields in de.dhbwstuttgart.typeinference.typedeployment declared as Menge
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Field and Description
    --- | ---
    `(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.`sigma`
    `(package private) Menge` | FC_TTO.`TTO`

    Methods in de.dhbwstuttgart.typeinference.unify that return Menge
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `static Menge<Pair>` | Unify.`copyMengePair(Menge<Pair> vp)`
    `private static Menge<Type>` | Unify.`copyMengeType(Menge<? extends Type> vec)` Kopiert einen Menge.
    `private static Menge<Menge<Pair>>` | Unify.`generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)` Diese Methode generiert einen Menge> 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
    Modifier and Type | Method and Description
    --- | ---
    `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> 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
    Modifier and Type | Method and Description
    --- | ---
    `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.
    `static Menge<Pair>` | Unify.`copyMengePair(Menge<Pair> vp)`
    `private static Menge<Type>` | Unify.`copyMengeType(Menge<? extends Type> vec)` Kopiert einen Menge.
    `private static Menge<Menge<Pair>>` | Unify.`generateSetOfSetOfPair(Type TA1, Menge<? extends Type> otherPairTypes)` Diese Methode generiert einen Menge> 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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `private <A> void` | KeineDoppeltenVerweise.`check(Menge<Menge<A>> cP)`

  - ### Uses of Menge in plugindevelopment.MartinTestCases

    Methods in plugindevelopment.MartinTestCases with parameters of type Menge
    Modifier and Type | Method and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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)`