de.dhbwstuttgart.typeinference.assumptions

## Class TypeAssumptions

- java.lang.Object
- - de.dhbwstuttgart.typeinference.assumptions.TypeAssumptions

    public class TypeAssumptions
    extends java.lang.Object

Eine Sammlung von TypeAssumptions. Jede Expression und jedes Statement erhÃ¤lt beim Aufrufen ihrer TYPE-Methode ein AssumptionSet mit den Assumptions ihrer Umgebung als Parameter Ã¼bergeben.

Author:
  janulrich Es gibt verschiedene Assumptions: 1. Methoden Assumptions 2. Konstruktor Assumptions 3. Lokale Variablen Assumptions 4. Feldvariablen Assumptions

### Field Summary

Fields
`private Menge<ClassAssumption>` `classAssumptions`
`private Menge<ConstructorAssumption>` `constructorAssumptions`
`private Menge<FieldAssumption>` `fieldAssumptions`
`private Menge<GenericVarAssumption>` `genericVarAssumptions`
`private Menge<LocalVarAssumption>` `localVarAssumptions`
`private static Logger` `log`
`private Menge<MethodAssumption>` `methodAssumptions`
`private Menge<ParameterAssumption>` `parameterAssumptions`
`private JavaClassName` `thisClassName`

### Constructor Summary

Constructors
Constructor and Description
`TypeAssumptions()` Dieser Konstruktor setzt bei der Initialisierung auch den Wert von "this"
`TypeAssumptions(JavaClassName thisClassName)`

### Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
`TypeAssumptions` `add(TypeAssumptions assumptions)`
`private void` `addAllAssumptions(Menge<Assumption> assumptions)`
`void` `addAssumption(Assumption ass)`
`void` `addClassAssumption(ClassAssumption classAssumption)` FÃ¼gt eine TypAssumption an.
`void` `addGenericVarAssumption(GenericTypeVar genericTypeVar)` FÃ¼gt eine Generische Typvariablen den Assumptions hinzu
`Type` `checkType(RefType type, SyntaxTreeNode parent)`
`TypeAssumptions` `clone()`
`private Menge<Assumption>` `getAllAssumptions()`
`private Menge<FieldAssumption>` `getAssumptionsFor(JavaClassName className)` Liefert alle Assumptions, auÃer die der lokalen Variablen, welche einer bestimmten Klasse zugeordnet sind.
`Menge<ClassAssumption>` `getClassAssumptions()`
`ConstructorAssumption` `getConstructorAssumption(java.lang.String className, int paramCount)`
`Menge<FieldAssumption>` `getFieldVars(java.lang.String withName)` Liefert alle bekannten Ã¶ffentlichen Feldern mit dem Namen withName.
`Menge<MethodAssumption>` `getMethodAssumptions(JavaClassName className, java.lang.String methodName)` Sucht nach MethodAssumptions einer bestimmten Klasse mit einem bestimmten Namen.
`Menge<MethodAssumption>` `getMethodAssumptions(java.lang.String methodName, int parameterCount)` Sucht nach Assumptions zu einer Methode mit dem Namen methodName und parameterCount Parametern.
`Menge<MethodAssumption>` `getMethods2(java.lang.String withName)` Deprecated.
`ConstraintType` `getTypeFor(Type t, SyntaxTreeNode inNode)` Kontrolliert den vom Parser gesetzten Typ.
`Type` `getTypeOfFieldVar(java.lang.String withName, Class inClass)` Liefert den Typ einer Feldvariable der Klasse inClass
`Type` `getTypeOfLocalVar2(java.lang.String withName)` Deprecated.
`Type` `getVarType(java.lang.String variableName, Class inScope)` Durchsucht die Assumptions des aktuellen GÃ¼ltigkeitsbereichs (lokale Variablen und Felder der aktuellen Klasse) nach einem Eintrag fÃ¼r den Ã¼bergebenen Variablennamen.
`java.lang.String` `toString()`

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

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

### Field Detail

#### log

    private static final Logger log

#### thisClassName

    private JavaClassName thisClassName

#### methodAssumptions

    private Menge<MethodAssumption> methodAssumptions

#### constructorAssumptions

    private Menge<ConstructorAssumption> constructorAssumptions

#### fieldAssumptions

    private Menge<FieldAssumption> fieldAssumptions

#### localVarAssumptions

    private Menge<LocalVarAssumption> localVarAssumptions

#### parameterAssumptions

    private Menge<ParameterAssumption> parameterAssumptions

#### genericVarAssumptions

    private Menge<GenericVarAssumption> genericVarAssumptions

#### classAssumptions

    private Menge<ClassAssumption> classAssumptions

### Constructor Detail

#### TypeAssumptions

    public TypeAssumptions()

Dieser Konstruktor setzt bei der Initialisierung auch den Wert von "this"

Parameters:
  `klassenname` - - Wert fÃ¼r "this"

#### TypeAssumptions

    public TypeAssumptions(JavaClassName thisClassName)

### Method Detail

#### getFieldVars

    public Menge<FieldAssumption> getFieldVars(java.lang.String withName)

Liefert alle bekannten Ã¶ffentlichen Feldern mit dem Namen withName. Dabei werden alle bekannten Klassen durchsucht.

Parameters:
  `withName` -
Returns:

#### getTypeOfFieldVar

    public Type getTypeOfFieldVar(java.lang.String withName,
                                  Class inClass)

Liefert den Typ einer Feldvariable der Klasse inClass

Parameters:
  `withName` -
  `inClass` -
Returns:
  null, falls die Klasse kein zugÃ¤ngliches Feld enthÃ¤lt

#### getMethods2

    @Deprecated
    public Menge<MethodAssumption> getMethods2(java.lang.String withName)

Deprecated.
Ermittelt alle bekannten Methoden mit dem Namen withName

Parameters:
  `withName` -
Returns:

#### getTypeOfLocalVar2

    @Deprecated
    public Type getTypeOfLocalVar2(java.lang.String withName)

Deprecated.
Liefert den Typ einer lokalen Variable. Zuerst werden die Parameter dieses AssumptionSets durchsucht, dann die lokalen Variablen. AnschlieÃend die Felder der, "this" reprÃ¤sentierenden Klasse

Parameters:
  `withName` -
Returns:

#### getMethodAssumptions

    public Menge<MethodAssumption> getMethodAssumptions(java.lang.String methodName,
                                                        int parameterCount)

Sucht nach Assumptions zu einer Methode mit dem Namen methodName und parameterCount Parametern.

Parameters:
  `methodName` -
  `i` - Die Parameter, welche die Methode verarbeiten soll
Returns:
  Alle Methoden in den Assumptions, welche eine Parameterliste der LÃ¤nge der Ã¼bergebenen Parameterliste (parameter) verarbeiten kÃ¶nnen.

#### getVarType

    public Type getVarType(java.lang.String variableName,
                           Class inScope)

Durchsucht die Assumptions des aktuellen GÃ¼ltigkeitsbereichs (lokale Variablen und Felder der aktuellen Klasse) nach einem Eintrag fÃ¼r den Ã¼bergebenen Variablennamen. In den Assumptions wird dann in der Reihenfolge LocalVarAssumptions, FieldAssumption nach dem Ã¼bergebenen Variablennamen gesucht.

Parameters:
  `variableName` - - der Identifier der gesuchten Variablen
  `inScope` - - Sucht auch die Felder der Ã¼bergebenen Klasse ab. Hier kann auch null Ã¼bergeben werden, dann werden nur die Lokalen Variablen dieser TypeAssumption durchsucht.
Returns:
  - Der Typ fÃ¼r diesen Identifier, oder null, falls kein Typ vorliegt.

#### getMethodAssumptions

    public Menge<MethodAssumption> getMethodAssumptions(JavaClassName className,
                                                        java.lang.String methodName)

Sucht nach MethodAssumptions einer bestimmten Klasse mit einem bestimmten Namen.

Parameters:
  `className` -
  `methodName` -
  `parameterCount` -
Returns:

#### getAssumptionsFor

    private Menge<FieldAssumption> getAssumptionsFor(JavaClassName className)

Liefert alle Assumptions, auÃer die der lokalen Variablen, welche einer bestimmten Klasse zugeordnet sind.

Parameters:
  `className` -
Returns:

#### getAllAssumptions

    private Menge<Assumption> getAllAssumptions()

#### addAssumption

    public void addAssumption(Assumption ass)

#### addAllAssumptions

    private void addAllAssumptions(Menge<Assumption> assumptions)

#### add

    public TypeAssumptions add(TypeAssumptions assumptions)

#### clone

    public TypeAssumptions clone()

Overrides:
  `clone` in class `java.lang.Object`

#### toString

    public java.lang.String toString()

Overrides:
  `toString` in class `java.lang.Object`

#### getTypeFor

    public ConstraintType getTypeFor(Type t,
                                     SyntaxTreeNode inNode)

Kontrolliert den vom Parser gesetzten Typ. Erweitert dessen Bezeichnung, wenn nÃ¶tig.

Parameters:
  `t` -
Returns:
  null, falls der Typ nicht vorhanden ist.

#### addClassAssumption

    public void addClassAssumption(ClassAssumption classAssumption)

FÃ¼gt eine TypAssumption an. Dadurch wird ein Pool von Typen aufgebaut, welche Ã¼berhaupt erlaubt sind. Wird genutzt um vom Parser eingelesene Typen auf ihre Korrektheit zu kontrollieren.

Parameters:
  `classAssumption` -

#### getConstructorAssumption

    public ConstructorAssumption getConstructorAssumption(java.lang.String className,
                                                          int paramCount)

Returns:
  Null, falls kein Konstruktor vorhanden.

#### addGenericVarAssumption

    public void addGenericVarAssumption(GenericTypeVar genericTypeVar)

FÃ¼gt eine Generische Typvariablen den Assumptions hinzu

Parameters:
  `genericTypeVar` -

#### getClassAssumptions

    public Menge<ClassAssumption> getClassAssumptions()

#### checkType

    public Type checkType(RefType type,
                          SyntaxTreeNode parent)