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
    Modifier and Type | Field and Description
    --- | ---
    `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
    Modifier and Type | Method and Description
    --- | ---
    `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)