dotUML Software Design

XML-based UML Description Language

The major language specification document is an XML-schema document. It defines the language requirements in an xml-notation and matches the descriptive requirements of UML diagrams. All the main constructs are either self-descriptive or described with comments.
The user language guide will have detailed instructions on how to author xml-files.
Download XSD
Download Sample XML

dotUML.Core

The Core is the interface to the outside world. The client applications use this component to access the dotUML functionality. The following class diagram depicts its structure.
Core.jpg
The following entities are available on the diagram:

dotUML.Parser

The Parser contains the functionality to parse a diagram description in the form of an xml-file and to build an IModel (dotUML.Common) based on the xml-file content. The following class diagram depicts the Parser's structure.
Parser.jpg
The following entities are available on the diagram: XmlParserFactory - This class returns an instance of XmlParser class as an interface of IParser interface.
dotUML.Parser Flow
The following sequence diagram describes the order in which internal operations of dotUML.Parser are called.
ParserFlow.jpg
The steps can be briefly explained as follows:
1.: Get an externall call from a client application to process an xml-file.
1.1.-1.2.: Get an instance of IParser.
1.3.-1.4., 1.6.1.-1.6.2., 1.8.: Validate if the xml-file conforms to the xml-schema.
1.5.: Get an instance of IModel.
1.6.3., 1.6.3.1., 2.: Parse stereotypes and create model entries for stereotypes.
1.6.4.-1.6.5.: Parse sequence diagram elements and create model entries for them.
1.6.6.-1.6.9.: Validate a model.
1.7.: Return parsing results.

dotUML.Common

Common contains the means to present UML diagrams and their interrelations in memory. It has appropriate classes for all diagram elements and methods which allow to link diagram elements into a diagram. The following class diagram depicts its structure.
Common.jpg
The following entities are available on the diagram:
IModel - This interface enalbles other modules to build diagram memory representations (diagram models). It is the main public interface of dotUML.Common. Through this interface one can manage stereotypes and diagrams.
ModelFactory - This factory returns an instance of a model as IModel interface.
Model - This class implements the IModel interface.
IDiagram, ISequenceDiagram and IComponentDiagram - These interfaces describe the major properties and methods of diagrams.
DiagramBase, SequenceDiagram and ComponentDiagram - These classes implement appropriate interfaces.
SequenceDiagram package contains sequence diagram elements which inherit from abstract DiagramElement.
dotUML.Common Flow
The following sequence diagram describes the order in which internal operations of dotUML.Common are called.
CommonFlow.jpg
The steps can be briefly explained as follows:
1.-2.: Obtain an instance of IModel.
3.-4.: Add stereotypes to the model.
5.-5.2.: Create a new sequence diagram.
6.-6.2.: Add a new lifeline.
7.-8.: Associate a lifeline with a stereotype.
9.-12.: Add a new element to the diagram. Check whether an element with the same name already exists before adding.
13.-14.: Resolve proxies. While parsing, objects can be linked with dummy objects. For example, a message can be linked to a dummy lifeline and after parsing this dummy lifilene will be replaced with a real one.
15.-15.1.: Number messages.
16.-19.: Validate the model and process validation results.

dotUML.Graph

Graph contains all the functions to draw the diagrams inside a Model. It contains a visual representation of each diagram element inside the model and pays attention to their visual dependencies and visual structure. Graph uses the Windows Presentation Foundation to render the diagram. Its class structure is shown in the following diagram.
Graph.png
The following entities are available on the diagram:
dotUML.Graph Flow
The following sequence diagram describes the order in which internal operations of dotUML.Common are called.
GraphFlow.png
The steps can be briefly explained as follows:
1-2: Create an instance of IRenderer via the RendererFactory
3: Call to the IRenderer, passing the IModel
3.1, 3.1.1, 3.1.2: IRenderer is using the appropriate instances of IVisualDiagram to build up the visual representation of the diagram: A system of IVisualDiagramElements
3.2: Arrangement of the items in order to produce a good layout
3.3: The render process is using WPF to produce an image, IRenderer collects all the output images.
4: Return of List<DiagramImages> to the caller

dotUML.System

dotUML.System contains the low-level service things like base exception types and logging. Logging is embedded into the code via Spring.Net Aop. The following class diagram gives an overview of the dotUML.System component.
System.jpg
The following entities are available on the diagram:
Logger - a singleton logger called from aspect code.
dotUMLException - a base exception class.

dotUmlConsole

dotUmlConsole is a console client application, which uses dotUML framework. The following diagram depicts its structure.
dotUmlConsole.jpg
The following entities are available on the diagram:
Program - This class has a number of methods to accept the user input, verify it, use IDiagramEngine to process an xml file and to save the diagrams as images to the specified location on the disk.
DiagramEngineFactory and IDiagramEngine belong to the dotUML.Core.
dotUmlConsole Flow
The following sequence diagram describes the order in which internal operations of dotUmlConsole are called.
dotUmlConsoleFlow.jpg
The steps can be briefly explained as follows:
1.: The user calls dotUmlConsole and specifies a path to an xml-file and a target path.
1.1.-1.3.: Validate input and provide help in case of invalid input.
1.4.: Load the xml-file.
1.5.-1.5.2.: Get a new diagram engine.
1.6.-1.9.: Validate the xml-file versus xsd.
1.10-1.15.: Process the xml-file and save the images. In case of errors provide help.