Version von "maven-site-plugin" angehoben und vereinheitlicht, um "java.lang.ClassNotFoundException: org.apache.maven.doxia.siterenderer.DocumentContent"-Fehlermeldung zu umgehen — Christoph Schulz / detail

#485 (May 29, 2016, 2:02:26 PM)

- Added the Checkers for Inheritance of Exception Types
- Oparation now know whitch operation they override. — hfi413du / detail

#484 (May 27, 2016, 5:34:48 AM)

Core: - Fixed the AnalyzeInheritancePath.
- Tested the correctness of the new algorithm with all available test cases and additional tests with own models.
- Fixed the @Ignore complexTestCase (it was wrong).

— Teickner Achim / detail

#483 (May 26, 2016, 11:02:17 AM)

Core: - Fixed bug when generating super constructor calls for models such as:

de : group = [
fhdw : group = [
parts : group = [
state : group = [
# represents a state that a product can have #

# represents a state of a product with nothing cached #
NothingCachedState : class = {
();
};

A : class = {
();
};

# represents a state of a product with cached price #
PriceCachedState : class = A + NothingCachedState + {
()=A()+NothingCachedState();
};

# represents a state of a product with cached material list #
MaterialListCachedState : class = NothingCachedState + {
()=NothingCachedState();
};

# represents a state of a product with cached price and materialList #
PriceAndMaterialListCachedState : class = PriceCachedState + MaterialListCachedState + {
()=NothingCachedState()+PriceCachedState()+MaterialListCachedState();
};
];
];
];
];

The open ended path in this example caused a wrong call order.
This has been fixed by removing certain open ended paths from the paths that will be intercepted. — Teickner Achim / detail

#482 (May 25, 2016, 8:22:11 PM)

Core: - Altered the task so that not only the order of direct super types (as given by the user) is being respected but also the implicated order of all classes at same inheritance tree stages.
The following example model shows which problem has been solved:

de : group = [ fhdw : group = [ parts : group = [ # represents a component which can be either a material or a product # A : class = { (); }; B : class = A +{ ()=A(); }; C : class = A + { ()=A(); }; X : class = { (); }; Y : class = X + { ()=X(); }; Z : class = X + { ()=X(); }; H : class = Z + Y + C + B + { ()=X()+A()+Z()+Y()+C()+B(); }; ]; ]; ];

when analyzing the inheritance tree of class H the resulting super constructor call order should be
{X,Z,Y,A,C,B}.
Before the change made in this commit the (wrong) result would have been as following:
{A,X,Z,Y,C,B}.
This is wrong because when iterating through the steps of the inheritance tree from left to right when respecting the order of direct super types as given by the user one will iterate over X first because its subclass Z occurs before any subclass of A.
Additionally (and a much more important reason) with the wrong result the This-pointer of X and not the pointer of A would be available for the classes C and B. C and B however need the This pointer of A and should not see the this pointer of X.

Moreover the new algorithm is much simpler compared to the old solution because the old solution needed to iterate over a map in a very complicated fashion whereas the new algorithm profits from the fact that the instaces of the inner class InheritanceTree run through the whole tree in the right order. Thus instead of comparing inheritance-tree-paths in the order from 'left' to 'right' to a copied collection of the same paths from 'left' to 'right' the comparison is now made with the paths from 'left' to 'right' with the reversed copy of paths (thus from 'right' to left). — Teickner Achim / detail

#481 (May 25, 2016, 4:57:12 PM)

Core: - Made Collection of super types in all types to a list because order is important here!
- Fixed AnalyzeInheritancePathsTask to respect the order of the direct super types of a root class so that the super type order is the same as the order of the called super constructors.
- Fixed two test cases which expected the 'wrong' order of super constructor calls. — Teickner Achim / detail

#480 (May 13, 2016, 8:32:26 AM)

Core + CoreTest: Namen von Attributen sind zukünftig einmal pro Klasse erlaubt, nicht wie zuvor einmal pro Hierarchie. Testfälle angepasst. — hfw413sc / detail

#479 (May 8, 2016, 2:52:51 PM)

Core: - Fixed a bug where sum types that contain the class that has to "instantiate" it (what is impossible) have been removed but the class references a constructor of a supertype of this sum-type.
Generator: - Fixed all test cases that didn't pass due to the changes made in my previous commit... — Teickner Achim / detail

#478 (May 8, 2016, 12:32:08 PM)

Core: - Added check regarding the existence of at least one constructor in the ConstructorReferencer.
This means that all classes defined in wtf-models need an explicitely defined constructor from now on!

CoreTests: - Adapted test models to the change above by adding constructors.
Generator: - No Constructors will be generated anymore if the constructor list of the ast type is empty.
- For every constructor in the AST-types list a constructor with the mutable map as parameter (calling $super) and another constructor without the mutable map that calls the constructor with the mutable map will be generated from now on.
- Adapted test cases due to the changes above (Added constructors). — Teickner Achim / detail

#477 (May 6, 2016, 9:28:01 AM)

Core: - Added more precise exception-messages. — Teickner Achim / detail

#476 (May 5, 2016, 8:17:59 AM)

Unnütige Änderungen, die vorher getan wurden, wurden hier entfernt.
An der weiteren Verarbeitung hat sich nichts geändert. — hfi413kl / detail

#475 (May 4, 2016, 5:57:54 PM)

Core: - Changed Order of called Tasks: The AnalyzeInheritanceTreeTask must run after the ConstructorReferencer because the ConstructorReferencer influences the hashCode-method of types which would make types with ConstructorReferences unaccessible in the map produced by the AnalyzeInheritanceTreeTask when the AnalyzeInheritanceTreeTask runs before the ConstructorReferencer. — Teickner Achim / detail

#474 (May 4, 2016, 5:12:53 PM)

Core: - Altered AnalyzeInheritanceTreesTask to skip such sum types which have the root class of the viewed inheritance tree as element as these don't have to be instantiated explicitly.
- Altered ReferencedConstructors check to replace sums that do not match the criteria above to be replace by the sum type element mentioned in the corresponding constructor as a sum type itself cannot be instantiated but a constructor call to one of its elements must exist if the caller is not part of the sum type itself.

Generator: - Sorted the ConstructorCallGenerationTask into the generation procedure.
- Moved the generation of $super/setThis-methods and constructors to the ConstructorCallGenerationTask and removed their counterparts from the OperationAttributeTransformer and the GenInterfaceWithImplClass.
- Implemented the generation of parameterized $super-Methods per constructor.
- Fixed test cases that expected generated parts after the OperationAttributeTransformer which are not being generated by it anymore. — Teickner Achim / detail

#473 (May 4, 2016, 8:22:52 AM)

- Added Checkers
- In NoThrownListTypesCheck there is still a little toDo
- handel it after my visit at the doctor ;) — hfi413du / detail

#472 (May 4, 2016, 2:06:34 AM)

Gruppenübergreifende symmetrische Beziehungen funktionieren jetzt...
...das Separieren von Attributen, je nach Gruppe, wird jetzt nicht mehr durchgeführt. — Hoyer Steffen / detail

#471 (May 4, 2016, 1:52:53 AM)

- *-Problem bei Attributen (weil im Attributs-Namen ein * enthalten) gelöst
- Reflexive Assoziationen funktionieren
- x : A symmetric(x) -> Funktioniert nicht (wird nicht vom Checker durchgelassen), was auch genau so gewollt ist
- Debug-Ausgabe als Option eingebaut
- TODO: Gruppenübergreifende symmetrische Beziehungen fehlen noch — Hoyer Steffen / detail

#470 (May 3, 2016, 10:42:52 AM)

[Core/.../ast/type]
=> In Type eine Methode standardize eingefügt und in den jeweiligen Typen implementiert.
=> In Type eine Methode IsThrownType einfügt, die aussagt, ob der konkrete Typ ein ThrownType ist
[CoreTests]
=> Testfälle angepasst
[Generator/.../java/visitor]
=> GenClassClassVisitorException hinzugefügt
[Generator/.../ java/generatorModel]
=> In den jeweiligen spezielleren Klassen von GenClassClass die accept-Methode implementiert
[Generator/.../ transformers/classTransformer]
=> TypeTransformer und GeneratorModel so angepasst, das dort nun eine HashMap existert, die von einem AST-Typ auf ein Tuple von einem GenType und einer Collection von ExceptionClassTypes abbildet um so später bei der Zuordnung zu den Operation die Exceptions leichter gefunden werden können.
=> OperationAttributeTransformer: Die Umstellung der oben erwähnten HashMap eingebaut

— hfi413kl / detail

#469 (May 1, 2016, 11:47:42 PM)

Core: - Removed unneeded operations and methods which were only used in the deleted AddNonExplicitelyDefinedConstructorsTask. — Teickner Achim / detail

#468 (May 1, 2016, 11:23:25 PM)

Core: - Removed AddNonExplicitlyDefinedConstructorsTask because it causes inconsistencies in the AST. Default constructors can be added in the generator model instead (they can be detected by looking for empty constructor collections in types).
- Overhauled ReferencedConstructorsCheck to work with the results of the analysis of the inheritance trees.
- Rearranged Tasks in the AbstractSyntaxCheck to fit the new circumstances. (Maybe got also rid of an error but this is not for sure)
Generator: - Removed the "constructorProduct" from test cases as it doesn't exist anymore due to the missing AddNonExplicitelyDefinedConstructorsCheck. — Teickner Achim / detail

#467 (May 1, 2016, 4:37:01 PM)

Core: Preparation for the overhaul of the ConstructorReferencesCheck and the generation of $super-Methods:
- Moved analysis of the inheritance trees from the Generator-project to a new task in the Core-project: AnalyzeInheritanceTreesTask.
The results of this task (a map that shows which class has to call constructors of which super classes) is now part of the AST-Model, thus
- Added a new field to the AST-Model (Model.java) which holds the result of the new AnalyzeInheritanceTreesTask.
- Added methods to retrieve the new field from the Model and to put pairs of the form (Type, List<Type>) into the new map.
- Integrated the new Task in SyntaxCheckAbstract
- Adjusted a test case (It asserted an exception that does not occur due to the changes made in SyntaxCheckAbstract. Instead another Exception occurs now that is being asserted). — Teickner Achim / detail

#466 (May 1, 2016, 3:02:45 PM)

Core: - Added an implementation for getSuperTypes(). — Teickner Achim / detail

#465 (Apr 27, 2016, 1:30:49 PM)

Fehlermeldung in SymmetricCheck angepasst — Hoyer Steffen / detail

#464 (Apr 27, 2016, 1:17:30 PM)

- Fixes the bug refering to the equals checking comparing types by string representation — hfi413pi / detail

#463 (Apr 27, 2016, 12:52:30 PM)

Auf der Suche nach einem Bug: Protokollierung eingebaut! — Hoyer Steffen / detail