The rCOS Modeler is an ongoing and collaborative project to develop an integrated modelling platform to support model driven and component-based software development. It is based on the formal theory and method of rCOS - Refinement of Component and Object Systems. With an UML profile for the rCOS modelling language, the tool provides  UML-Based Multi-View modellinge platform with an evolving architecture to allow further plug-ins.

The rCOS Modeler supports the application of the rCOS theories and Method for modelling construction, analysis, verification and transformations for correctness preserving transformations; and it generates prototypes form requirements models, and verifiable code from design models.

Model-Driven and Component-Based Development with rCOS Modeler:

Support use case-driven software requirements modelling in the phase of requirements capture and analysis. At these phase, a model of requirements are defined in terms of the following clearly inter-related models.

GUI for textual description of use cases in formatted English and use case diagrams.

GUI for use-case sequence diagrams for the use cases, conceptual class models with conceptual classes, associations among classes and attributes of classes, but little information about what the objects of these classes do, i.e. methods of classes are not concerned.

GUI for use-case operations, also called system operations, are identified from the use-case sequence diagrams, the input and output parameters of the operations, and contracts of the operations specified as the pre-and post-conditions of the operations. The contracts can be first described using structured English, and then formally in a first order logic or the object constraint logic (OCL).

GUI for state diagrams to model dynamic behaviour of use cases (components) for application-oriented verification.

taking use cases as components, component-based model of the requirements are then automatically generated from the use-case diagrams, use-case operations and their contracts, called the Model of Architecture at the requirements phase.

The tool provides functionality for checking the consistencies among the use case descriptions, use case diagrams, use-case sequence diagrams, conceptual class diagrams, system operations, contracts of operations, and the consistency between the use-case sequence diagrams and their corresponding state diagrams. These consistency relations are well studied in rCOS (but partial implemented in the tool).

Support use-case driven (thus component-based), iterative and incremental design. We take each use case in the requirements model, i.e. the model of each component in the model of architecture at the requirements phase, design the interactions among objects for the realisation of the contract of each use-case operation following the object-oriented design patterns (Patterns for Assigning Responsibilities - GRASP). These patterns are formalised and proven as rules for refinement of sequence diagrams in rCOS. The tool support

GUI for taking each use-case sequence diagram in the requirements model, based on the conceptual class model and the contract of each operation in the use-case sequence diagram, apply GRASP to refine the use-case sequence diagram to an object sequence diagram (object collaboration diagram can also be used), called a design sequence diagram for the use case.

The interactive tool for refinement of a use-case sequence diagram automatically transforms, behind the scene, the conceptual class model into a design class model by adding the names for the methods and method invocations in their bodies (i.e. a kind of programming by drawing).

An interactive model transformation tool,called OODM2CBDM, is implemented to transforming an object sequence diagram, i.e. a design sequence diagram, into a component sequence diagram. This is done as follows: the user select some lifelines (i.e. objects) in the object sequence diagram as “component candidates”’; the tool automatically check the necessary semantic conditions for a component; after the checking is passed (otherwise the user select candidates), a component-based sequence diagram is generated; and finally a component diagram is automatically generated, decomposing a use case (a component at the requirements level) into the composition of sub-components.

Support code generation: rCOS lift the burden of coding by programmers to the requirements analysis and design phases with design patterns and factoring of models.

names methods of classes and method invocations are automatically generated in the interactive design phase using the tool following the OO design patterns; leaving significant algorithms for computations for the programmer to implement, such as computing the greatest common divisor of two integers (note existing components for such algorithms may exists and used as components).

a tool RM2PT is provided for automatic prototyping from a requirements model, to support requirements validation.

before and/or after code generation, refactoring can be applied as model transformations; a sound and complete set of refactoring rules of for rCOS OO models are provides (yet to implement).

图片 1

The rCOS modeler is implemented on top of the Eclipse platform using a UML profile, ensuring compatibility with other UML-based software engineering tools. The tool is structured around different Eclipse plugins. These plugins can be split into the following categories:

modelling: extend the EMF/UML modelling capabilities of Eclipse

programming: non-GUI Java implementations, parser

GUI extensions: graphical UML modeler