| Home >> All |
| • | tudresden.ocl.* (315) |
Package Samples:
• tudresden.ocl.codegen.decl: This package contains interfaces that the class tudresden.ocl.OclTree uses to access code generators, some classes to support the implementation of code generators especially for procedural languages, and a code generator for Java.
• tudresden.ocl.parser: The package tudresden.ocl contains some utility classes that are needed for several compiler modules, such as NameCreator , and some classes for the visualization of abstract synatx trees (ASTs).
• tudresden.ocl.test.royloy: In this package, the JUnit 1.0 component testing framework is used to test the OCL compiler.
• tudresden.ocl.check.bootstrap: This package contains classes for checking the semantical correctness of OCL expressions.
• tudresden.ocl.injection.reverseeng: Injects code fragments checking OCL contraints into user java code.
• tudresden.ocl.gui.events
• tudresden.ocl.gui
• tudresden.ocl.lib.test
• tudresden.ocl.lib
• tudresden.ocl.sql.gui
• tudresden.ocl.sql.orstrategy
• tudresden.ocl.sql
• tudresden.ocl.test.sql
• tudresden.ocl.test
• tudresden.ocl.codegen
• tudresden.ocl.check.types.testfacade
• tudresden.ocl.check.types.xmifacade.stress
• tudresden.ocl.check.types.xmifacade
• tudresden.ocl.check.types
• tudresden.ocl.check
Classes:
• OclCollection: This class is the abstract superclass of the OCL collection classes Set, Bag and Sequence. All these classes are implemented as adapter classes around classes of the Java 2 (= JDK1.2) collection framework. The java.lang.Collection backing OclCollections are required to contain only objects of type OclRoot . That should be considered when calling the constructors of OclCollections that take java.lang.Collections. Iterating methods A central feature of the collections defined in the OCL specification are operations that have an OCL expression as their parameter. These methods are exists , forAll ...
• ReflectionFacade: ReflectionFacade implements ModelFacade by extracting the required information from compiled Java classes via Java Reflection. The package name where classes are to be found is given as constructor parameter, along with a ReflectionAdapter object that is used to map Java classes to OCL types and vice versa. Classes are then loaded using the standard Java class loader. While this approach is very flexible, it has some serious drawbacks. Association ends with a multiplicity greater than one are usually represented in Java classes as some Java collection type, e.g. java.util.Vector . Through static ...
• Model: Implements ModelFacade using model information of a xmi file. The actual Model object can be in one of two modes. In the first mode, called "not rough", the Model has flattened generalization relationships and dissolved associations. In the second mode, called "rough", the Model's generalizations relationships are not flattened and the associations are not dissolved. This mode enables the user of the Model to query the object oriented information from a more structural point of view. Additional notes: An attribute overrides an inherited attribute, if and and only if it has the same name. Ordinary ...
• Ocl: This class constitutes the central interface to generating classes in the OCL class library. An application should call one of the getOclRepresentationFor class methods whenever it wants to use any object or value with the library. This method than consults the installed OclFactory to create the correct representative for this object or value. The getFor methods are nothing but a shorthand for getOclRepresentationFor , which is self-speaking but tedious to write. If the OCL class library is to be used in a new context, especially with a new code generator, a new OclFactory might become necessary. ...
• OCL2SQL: OCL2SQL is the main class of the OCL2SQL tool. It manages all the different components and the flow of information between them which generate some kind of SQL code. These components are: ORMappingImp - for the object relational mapping SchemaGenerator - the generator of table schemas ObjectViewSchema - the object view generator and object relational interface for the integrity view generator ILSQLCodeGenerator - the integrity view generator TriggerGenerator - the generator that creates SQL92-Assertionreplacement triggers and ECA-trigger-templates The purpose of the tool is to demonstrate the usability ...
• ORMappingImp: An implementation of the ORMapping interface. It generates a number of tables for classes and associations according some rules that are parameterized. The source of the object oriented information is a Model object that must be of rough quality. The rules are as follows: Classes map to one ore more tables according to the parameter classToTableMode . The class tables are going to get a primary key consisting of a certain number of columns ( numOfPKCols ) of a specified datatype ( pKColTypeName ). All primary key columns have the same datatype. The keys follow the existence based approach and are ...
• DeclarativeCodeGenerator: This class provides functionality to generate declarative code such as SQL by traversing the abstract syntax tree in reversed depth first order. The basic concept is simple substring replacing in a StringBuffer. Therefore placeholders are going to be created and inserted at the proper positions within the buffer. The task of replacing these placeholders with target code is up to the nodes of the abstract syntax tree. To associate nodes of the syntax tree with such tasks, a Hashtable is used provided by AnalysisAdapter. It contains the nodes as keys and the tasks (placeholders) as elements. It can ...
• Type: This interface is used by the type checker to handle type representations. Classes implementing this interface will have their navigate methods return the type representation of the type of the association end with the name name or the type of the property name . In both cases the result can either be a application-defined type or a predefined type (basic type like Integer or collection type). Take care to return Sequences for navigation over ordered associations. If the type has no association end or property with the given name , a OclTypeException is thrown. Classes implementing this interface ...
• Table: This class represents metadata about tables of relational databases. A table consists of: - an arbitrary number of columns; - a primary key consisting of zero ore more columns; - foreign key references consisting of zero or more columns; The columns of the table can be associated to an attribute name that can be different from the real column name. The columns of the table can have a type. Since the metadata is not dependend of a specific database system, no special types are prescribed. It is suggested to follow the java basic data types like int, long, boolean, real and so on and map them to ...
• AnalysisConsumer: InjectionConsumer used to check for presence of element-type tags in a JavaFile. After processing of a Java source file, m_lcdCollections 55 will contain a list of all collections in the source file, together with their respective element-type tag. In addition, each element of the list stores information that can be used to identifiy the exact comment where to place the element-type tag when saving the modified file. m_lmdMaps 55 will contain a list of similar entries for each map in the analysed file. Note that this scheme only work if the Java Source code is not modified externally between analysis ...
• Guide: This class holds information about navigation in relational schemes as kind of steps of select-from-where clauses. One guide is dedicated to describe either navigations over tables or simple attribute access. If a guide is dedicated to describe a navigation or attribute access can be queried by the according methode. If a navigation or attribute access requires more than one table access, each access must be described with a separate Guide object. In that case, MappedClass objects then return an array of Guide objects. Guides must lead from the target table to the table from where the navigation ...
• ReflectionAdapter: This interface is required for compile-time type checking with the class ReflectionFacade. It is comparable to tudresden.ocl.lib.OclFactory but operates on meta level. In many cases consistency between the used implementation of this interface and the implementation of OclFactory will be desired. A homomorphism between OCL types, the type Boolean and the relation oclConformsTo:OCL-Type, OCL-Type -> Boolean on the one hand and Java types, the type Boolean and javaConformsTo:Java-Type, Java-Type -> Boolean on the other hand is necessary for ReflectionFacade to work properly; it may be broken ...
• ProceduralCodeGenerator: Subclasses should overwrite only inXxx/outXxx/caseXxx methods of nodes " below " AConstraintBody (below means nodes such that their production can be derived from the production constraint_body ). The methods inAConstraintBody and outAConstraintBody may be overwritten, but not caseAConstraintBody . This is not enforced by declaring methods final to allow those who know what they are doing to change behaviour in these methods. After leaving outAConstraintBody subclasses must leave a variable name for the AConstraintBody 's Expression object in the map ncm . This name is then taken as the ...
• OclFactory: A interface defining operations expected of a OCL representation factory class. Such a factory can transform any piece of application data (Java basic values and objects) into the corresponding representation for the OCL class library. This interface has to be implemented directly or, more usually, through DefaultOclFactory , to adapt the class library to "different" application code. Application code can be "different" for example in the way it implements non-unary associations. Such an adaption may be necessary if the class library is used with an other code generator, but usually the implementation ...
• OclIterator: The OclIterator is needed to transform OCL iterating methods to Java. An OclIterator can be obtained from an OclCollection and is given back to the OclCollection as an argument of the iterating method. This class is a wrapper class around an java.util.Iterator . It differs from Iterator in the ability to set the pointer to the next element once and then read this element arbitrarily often. In contrast, Iterator moves the pointer every time the element is read. When constructed, the OclIterator s pointer is before the first element. Calling getValue() would yield null .
• DDLGenerator: A DDL (Data Definition Language) generator. The generator takes a ORMapping implementation as input and generates a script that contains a number of table definitions including primary and foreign key references. Which tables are going to be created is determined by the implementation of ORMapping, which does the actual object relational mapping. The DDLGenerator just queries the information produced by the implementation of ORMapping and generates the appropriate DDL script. The generated DDL script is executable on Oracle 8i. To adapt the Generator for other database systems, just subclass DDLGenerator ...
• MappedClass: This class represents a mapped class from the object model. The class should be mapped using an implementation of ORMappingScheme. The four basic characteristics of a mapped class are: - a class can be mapped to one or more tables; - the mapped class knows about the kind of joins necessary to navigate to association ends; - an object identifier, necessary to uniquely identify instances of the class, can be mapped to one or more table columns; - an attribute can be mapped to one or more columns. To query all that important information about a mapped class, MappedClass provides a number of service ...
• OclStateAdapter: This interface must be implemented if OclAny s operation oclInState is used. The implementation must be able to check the state of objects. That can be done either in a object dependent way, or in object independent way if the state machines are generated by a CASE tool and that tools generation schemes permits a general solution. If the proposed way of state evaluation through OclState s String seems inadequate for performance reasons, consider creating a more efficient subclass of OclState , and a subclass of DefaultOclFactory that uses these custom OclStates.
• TypeTracer: Contains the log of object types found in a collection. Additionally provides static methods traceTypes(String,Collection) 55 and traceTypes(String,Map) 55 to be called from generated code. These logs are continuesly written to a log file, see log 55 for the file format.
• NodeNormalizer: By implementing this interface, normalizations on tree nodes are possible. More complex normalization steps might need to be implemented as TreeNormalizers. The class NormalizerPass, objects of which usually invoke NodeNormalizer objects, traverses an AST left-recursive, and calls the method normalize with each tree node before descending further "down" the tree (the trees root is on top, of course...). Modifications to the node will take effect immediatle, i.e. they will effect the further recursion. For token nodes, which are leaf nodes, the method normalize is not called.
• StandardAssociationMapping: This class handles all associations that are not handled elsewhere. It maps 3 basic kinds of Association 1 : 1 and 0..1 : 1 These associations are mapped to a buried foreign key in one of the tables. Navigation directions are taken into account if only one way is possible. 1 : N and 0..1 : N Mapped as buried foreign key in the table representing the N-multiplicity. If 0..1-multiplicity appears on corresponding association side, the foreign key may contain null-values N : M Mapped, using an association table, which will appear in associatioTables
• ModelAdjuster: a kind of filter for a MModel the data for object-relational mappings in ORMappingImpl is here made available. This includes: all MClassifiers being either a MClass or a MInterface and containing at least one Attribute or being part of and association or generalization all Inheritance root MClassifiers as above all Associations between MClassifiers and/or MInterfaces all Attributes having an undefined datatype as not being one defined in TypeManager nor an newly defined MClassifier Also null -entries are filled here
• TriggerGenerator: A trigger generator that can generate trigger definitions, which can be used to evaluate integrity views. Two kinds of trigger definitions are possible. Trigger definitions which serve as SQL92-assertion-replacements and ECA-trigger-templates. The trigger templates must be further edited by the application developer. The trigger generator takes care for multiple tables which can be involved in one integrity view evaluation. Hence, the information about the involved tables must be provided to the generator. The generator then generates one trigger per involved table.
• OclContainer: This class is a implementation of OclRoot that is backed by a "contained" OclRoot object. That contained object can be changed. OclContainer is necessary for the iterate operation on collections: The accumulator argument is initialized as an instance of OclContainer and can be updated with every iteration step. The method iterate is implemented to update the contained value of the OclContainer every step and return the contained value (NOT the OclContainer) after the iteration is complete.
• NameCreator: A class that provides unique names for the processing of OCL expressions. Such names are necessary for normalization and for generating Java code. A generated name consist of three parts: a prefix which is usually "tuddOcl", a part called infix that can be set by the caller (might be something like "Var" or "Inv", and a postfix part chosen by NameCreator to make the name unique. A special instance of this class can be accessed through the getInstance method, but a strict singleton pattern is not enforced to allow several name spaces.
| Home | Contact Us | Privacy Policy | Terms of Service |