Drawing UML Diagrams with UMLGraph

Introduction

There is no rule specifying that models should appear in a graphical form. A model is a simplification of reality, so a model for a software artifact could really be an outline of that artifact; think of a class definition without code in the method bodies. However, we usually prefer to examine many of our models in a graphical representation: UML employs ten different diagrams for visualizing different perspectives of a system.

Designers typically create their model diagrams using a drawing editor. However, all drawing editors require the tedious placing and manipulation of drawing shapes on the canvas. The effort and the motor coordination skills required for this activity are mostly irrelevant to the end result: unlike architectural or mechanical engineering models the appearance of a software system's model diagram is only marginally related to the quality of the represented software design.

Computer power and automatic graph drawing algorithms have now sufficiently advanced so as to allow the automatic placement of graph nodes on the canvas and the near optimal routing of the respective edges. We can therefore design models using a declarative textual representation and subsequently view, publish, and share them in graphical form. UMLGraph's support for declaratively specifying class and sequence diagrams is part of an ongoing effort aiming to support all ten types of UML diagrams.

Creating models in a declarative, textual notation offers a number of advantages.

• First of all, the model composition mechanism matches well both a programmer's high-level skills, the textual abstract formalization of concrete concepts, and the associated low-level skills, the manipulation of text using an editor and other text-based tools.
• The declarative notation, by being closer to the program's representation (the notation I experimented with is based on the Java syntax and semantics), forces the designer to distinguish between the model and the respective implementation, between the essential system characteristics and the trivial adornments. It is more difficult for designers to get away, as they often do now, with drawing for a model a nice picture of the implementation they have in mind.
• The declarative representation is also highly malleable, the existing visual structure does not hinder drastic changes, nor is effort wasted on the tidy arrangement of graph nodes a psychological barrier against massive design refactoring.
• Declarative models are also highly automatable: they can be easily generated from even higher-level descriptions by trivial scripts and tools operating on design process inputs such as database schemas, existing code, or structured requirements documents.
• With a declarative specification under the programmer's control a macro processors can be used for configuration management, allowing the same model to be used for generating diverse diagrams.
• Revision control and team integration activities can utilize the same proven tools and processes that are currently used for managing source code. Thus with a tool like Subversion or Git one can keep track of design revisions, create and merge branches, monitor model changes, and split work among a team.
• Finally, the declarative approach can readily utilize existing text processing tools for tasks that a drawing editor system may not provide.

• identify all classes containing a given field (as a prelude to an aspect-oriented cross-cut);
• count the total number of private fields in a given design;
• order methods appearing in multiple classes by their degree of commonality;
• identify differences between two designs.

Installation

1. Copy the files in lib to a directory you will use for storing UmlGraph's installation (for instance, /usr/local/lib).
2. Copy the file bin/umlgraph (for Unix) or bin/umlgraph.bat (for Windows) to a directory of your execution path (for instance, /usr/local/bin).
3. Adjust the above file, setting UMLGRAPH_HOME to point to the directory where you installed the UmlGraph library files.

UMLGraph is implemented as a javadoc doclet (a program satisfying the doclet API that specifies the content and format of the output generated by the javadoc tool). Furthermore, the output of UmlGraph needs to be post-processed with the Graphviz dot program. Therefore, to draw class diagrams with UmlGraph class you will need to have javadoc and Graphviz (http://www.graphviz.org/) installed on your computer. Both programs are freely available, from Sun and AT&T respectively, for many platforms including Unix and Windows. Javadoc is part of the Sun JDK, so a typical JDK installation will also include javadoc.

To draw UML sequence diagrams you must also install the free GNU plotutils (http://www.gnu.org/software/plotutils/plotutils.html) system.

Class Diagrams

The following is an example of a specification and the resulting UML class diagram:

class Person {         String Name; } class Employee extends Person {} class Client extends Person {}

Class Diagram Operations

There are various ways to invoke UMLGraph, each providing a different balance between convenience and flexibility.

Option 1: Using the Supplied Script

Option 2: Running Java

1. Specify the location of tools.jar as a part of Java's classpath and specify the full name of the UMLGraph doclet as an argument to Java. This is an invocation example under Windows
   java -classpath "lib/UmlGraph.jar;c:\program files\java\jdk1.6.0_02\lib\Tools.jar"
       org.umlgraph.doclet.UmlGraph -package Test.java
   
   and under Unix
   java -classpath '/usr/share/lib/UmlGraph.jar:/opt/Java-1.6/lib/tools.jar' \
   org.umlgraph.doclet.UmlGraph -package Test.java
   
2. Place the UmlGraph.jar file in a directory that also contains the Java SDK tools.jar file. You can accomplish this either by copying UmlGraph.jar to the SDK lib directory where tools.jar resides, or by copying the JDK tools.jar file into the directory where you installed UMLGraph. You then run
   java -jar /path/to/UmlGraph.jar yourfile1.java ...
   

To generate a diagram of all classes in the package specify as arguments to the Java invocation the name of the package and the directory where it resides. The following example generates a diagram of all UMLGraph classes.

Specifying some packages before the list of source files will designate those packages as local. When you specify a package list, the SVG output UMLgraph generates will contain local hyperlinks for the local classes and hyperlinks to the Sun Java API documentation for all other classes.

Option 3: Running Javadoc

Running Dot

You also can pipe the result of UMLGraph directly into dot:

Note that when you use dot for generating SVG diagrams your should specify the -outputencoding UTF-8 option to UMLGraph. This option will correctly render the stereotype guillemot characters in the dot output and the corresponding SVG file.

Class Modelling

• classes (specified as Java classes)
• active classes, components, nodes, use cases, collaborations, and packages (specified as Java classes with an @opt shape tag)
• attributes (specified as Java class fields)
• operations (specified as Java class methods)
• stereotypes (using the @stereotype name tag)
• tagged values (using the @tagvalue name value tag)
• implementation relationships (specified using the Java implements declaration)
• generalization relationships (specified using the Java extends declaration or (for multiple inheritance) the javadoc @extends tag)
• association relationships (specified using the javadoc @assoc tag)
• navigable (directed) association relationships (specified using the javadoc @navassoc tag)
• aggregation relationships (specified using the javadoc @has tag)
• navigable aggregation relationships (specified using the javadoc @navhas tag)
• composition relationships (specified using the javadoc @composed tag)
• navigable composition relationships (specified using the javadoc @navcomposed tag)
• dependency relationships (specified using the javadoc @depend tag)

1. The source adornments (role, multiplicity, and visibility)
2. The relationship name
3. The target adornments (role, multiplicity, and visibility)
4. The target class

class Tyre {} class Engine {} class Body {} /** * @composed 1 - 4 Tyre * @composed 1 - 1 Engine * @composed 1 - 1 Body */ class Car {}

Notes in Class Diagrams

/**  * @opt shape node  * @note Located in the  * machine room  * @note Sun Blade 6048  * @depend - - - MapLocation  * @depend - - - DataMine  */ class Server{} /** @opt shape component */ class MapLocation {} /** @opt shape component */ class DataMine {} /**  * CPU-munching  * components that must  * run on this server  * @opt shape note  * @opt commentname  * @assoc - - - MapLocation  * @assoc - - - DataMine  */ class munchComment {}

Class Diagram Options

What Gets Drawn

-all

Same as -attributes -operations -visibility -types -enumerations -enumconstants

-attributes

Show class attributes (Java fields)

-commentname

Name the element using the text in the javadoc comment, instead of the name of its class.

-constructors

Show a class's constructors

-enumconstants

When showing enumerations, also show the values they can take.

-enumerations

Show enumarations as separate stereotyped primitive types.

-hide

Specify entities to hide from the graph. Matching is done using a non-anchored regular match. For instance, "-hide (Big|\.)Widget" would hide "com.foo.widgets.Widget" and "com.foo.widgets.BigWidget". Can also be used without arguments, in this case it will hide everything (useful in the context of views to selectively unhide some portions of the graph, see the view chapter for further details).

-operations

Show class operations (Java methods)

-qualify

Produce fully-qualified class names.

-types

Add type information to attributes and operations

-view

Specify the fully qualified name of a class that contains a view definition. Only the class diagram specified by this view will be generated.
See the views chapter for more details.

-views

Generate a class diagram for every view found in the source path.

-visibility

Adorn class elements according to their visibility (private, public, protected, package)

Visual Appearance

-bgcolor

Specify the graph's background color.

-collapsible

Enhance the javadoc HTML files containing UML diagrams with Javascript that provides a link for showing the (initially collapsed) diagrams.

-edgecolor

Specify the color for drawing edges.

-edgefontcolor

Specify the font color to use for edge labels.

-edgefontname

Specify the font name to use for edge labels.

-edgefontsize

Specify the font size to use for edge labels.

-horizontal

Layout the graph in the horizontal direction.

-nodefillcolor

Specify the color to use to fill the shapes.

-nodefontabstractname

Specify the font name to use inside abstract class nodes.

-nodefontclassabstractname

Specify the font name use for the class name of abstract classes.

-nodefontclassname

Specify the font name to use for the class names.

-nodefontclasssize

Specify the font size to use for the class names.

-nodefontcolor

Specify the font color to use inside nodes.

-nodefontname

Specify the font name to use inside nodes.

-nodefontpackagename

Specify the font name to use for the package names (used only when the package name is postfixed, see -postfixpackage).

-nodefontpackagesize

Specify the font size to use for the package names (used only when it package name is postfixed, see -postfixpackage).

-nodefontsize

Specify the font size to use inside nodes.

-nodefonttagname

Specify the font name to use for the tag names.

-nodefonttagsize

Specify the font size to use for the tag names.

-nodesep

Specify the horizontal separation between the class nodes (0.25 by default). Decreasing this can make a diagram more compact.

-noguillemot

Specify that guillemot characters should not be used to denote special terms like "interface" and stereotype names. This is used on some platforms to circumvent problems associated with displaying non-ASCII characters.

-postfixpackage

When using qualified class names, put the package name in the line after the class name, in order to reduce the width of class nodes.

-ranksep

Specify the vertical separation between the class nodes (0.5 by default). Decreasing this can make a diagram more compact.

-shape

Specify the shape to use for the rendered element(s). The following UML shapes are available:

• class (default)
• node
• component
• package
• collaboration
• usecase
• activeclass

All colors can be either a symbolic name (e.g. blue), a tripple specifying hue-saturation-brightness as values 0-1 (e.g. ".13 0.9 1"), or a tripple specifying red-green-blue values as hexadecimal digits prefixed by a # (e.g. "#ff8020"). The symbolic color names are derived from the X Windows System; you can find a complete list in the Graphviz documentation (http://www.graphviz.org/doc/info/colors.html)

Font names are passed directly to the dot graph generation back-end. In general the Postcript standard names Times, Helvetica, Courier, and Symbol are safe to use.

Relationship Inference

-collpackages

Specify the classes that will be treated as containers for one to many relationships when inference is enabled. Matching is done using a non-anchored regular match. Empty by default.

-inferdep

Try to automatically infer dependencies between classes by inspecting methods and fields. See the class diagram inference chapter for more details. Disabled by default.

-inferdepinpackage

Enable or disable dependency inference among classes in the same package. This option is disabled by default, because classes in the same package are supposed to be related anyway, and also because there's no working mechanism to actually detect all of these dependencies since imports are not required to use classes in the same package.

-inferdepvis

Specifies the lowest visibility level of elements used to infer dependencies among classes. Possible values are private, package, protected, public, in this order. The default value is private. Use higher levels to limit the number of inferred dependencies.

-inferrel

Try to automatically infer relationships between classes by inspecting field values. See the class diagram inference chapter for further details. Disabled by default.

-inferreltype

The type of relationship inferred when -inferrel is activated. Defaults to "navassoc" (see the class modelling chapter for a list of relationship types).

-useimports

Will also use imports to infer dependencies. Disabled by default, since it does not work properly if there are multiple classes in the same source file (will add dependencies to every class in the source file).

API Hyperlinks

-apidocmap

Specify the file name of the URL mapping table. The is a standard Java property file, where the property name is a regular expression (as defined in the java.util.regex package) and the property value is an URL "root" as described above. This table is used to resolved external class names (class names that do not belong to the current package being processed by UMLGraph). If no file is provided, external classes will just be mapped to the on-line Java API documentation.

-apidocroot

Specify the URL that should be used as the "root" for local classes. This URL will be used as a prefix, to which the page name for the local class or package will be appended (following the JavaDoc convention). For example, if the value http://www.acme.org/apidocs is provided, the class org.acme.util.MyClass will be mapped to the URL http://www.acme.org/apidocs/org/acme/util/MyClass.html. This URL will then be added to .dot diagram and can be surfaced in the final class diagram by setting the output to SVG, or by creating an HTML page that associates the diagram static image (a .gif or .png) with a client-side image map.

-link

A clone of the standard doclet -link (http://java.sun.com/j2se/1.5.0/docs/tooldocs/windows/javadoc.html#link) option, allows UMLGraph to generate links from class symbols to their external javadoc documentation (image maps are automatically generated in UMLGraphDoc, you'll have to generate them manually with graphviz if using UMLGraph).

Operation

-compact

Generate compact dot files, that is, print HTML labels in a single line instead of "pretty printing" them. Useful if the dot file has to be manipulated by an automated tool (e.g., the UMLGraph regression test suite).

-d

Specify the output directory (defaults to the current directory).

-dotexecutable

Specify the path of the dot executable.

-linkoffline

Specify links to javadoc-generated documentation for external referenced classes. The -linkoffline option takes two arguments: the first for the string to be embedded in the href links, the second telling it where to find the package-list. Example:

-linkoffline http://developer.android.com/reference file:/home/doc/android/

See the javadoc documentation for more details.

-output

Specify the output file (default graph.dot). If the output directory is provided, -output can only specify a file name, otherwise a full path is accepted as well. If the filename specified is a dash, then the results are printed on the standard output, and can be directly piped into dot. Note that, in order to avoid javadoc messages to contaminate UMLGraph's output, you must execute UMLGraph directly as a jar, not through javadoc.

-outputencoding

Specify the output encoding character set (default ISO-8859-1). When using dot to generate SVG diagrams you should specify UTF-8 as the output encoding, to have guillemots correctly appearing in the resulting SVG.

-verbose2

Will print on the standard output details regarding the progress of graph generation. (Note that -verbose is a javadoc option with a different meaning).

Specifying class Diagram Options

Similarly, you can also globally specify options for all the note elements. through a class named UMLNoteOptions, as in the following example:

You can also change the UMLGraph operation on a per-class basis by using @opt attributes on individual classes. In this case the @opt specification temporarily overrides the particular global setting for the class being processed.

Finally, you can reset an option to its default value by prefixing it with an exclamation mark. For example:

Javadocs and UML class diagrams with UMLGraphDoc

• for packages, the diagram contains all of the classes in the package itself
• for classes, the set of classes somehow related to the current class

Class Diagram Views

The @view tag, marks a special class used to describe a single class diagram. Similarly to UMLOptions, the view can define its own general options, but allows to define overrides that allow to adopt different options for different classes based on regular expressions matching. The general syntax for defining a view is:

Each view will generate a .dot file whose name is the name of the view, unless the "output" option is specified to override it.

View inheritance

Class Diagram Example: Shapes

Class Diagram Example: Generalisation Relationships

/*  * Generalisation  * UML User Guide p. 141  */ /* Basic categorisations */ class Asset {} class InterestBearingItem {} class InsurableItem {} /* Asset types */ /**  * @extends InsurableItem  * @extends InterestBearingItem  */ class BankAccount extends Asset {} /** @extends InsurableItem */ class RealEstate extends Asset {} class Security extends Asset {} /* Securities */ class Stock extends Security {} class Bond extends Security {} /* Bank accounts */ class CheckingAccount extends BankAccount {} class SavingsAccount extends BankAccount {}

Class Diagram Example: Advanced Relationships

/*  * Advanced relationships  * UML User Guide p. 137  */ /**  * @opt attributes  * @opt operations  * @hidden  */ class UMLOptions {} class Controller {} class EmbeddedAgent {} class PowerManager {} /**  * @extends Controller  * @extends EmbeddedAgent  * @navassoc - - - PowerManager  */ class  SetTopController implements URLStreamHandler {         int authorizationLevel;         void startUp() {}         void shutDown() {}         void connect() {} } /** @depend - <friend> - SetTopController */ class ChannelIterator {} interface URLStreamHandler {         void OpenConnection();         void parseURL();         void setURL();         void toExternalForm(); }

Class Diagram Example: Relationships Inference

import java.util.List; import java.util.Map; import java.util.ArrayList; import java.util.Arrays; /**  * @opt inferrel  * @opt collpackages java.util.*  * @opt inferdep  * @opt inferdepinpackage  * @opt hide java.*  * @hidden  */ class UMLOptions {} class Person {     House[] houses;     List<Dog> dogs;          public Room getFavouriteRoom(House house) {} } /**  * @opt inferreltype composed  */ class House {     Map<String, Room> nameRoomMap; } class Room {} class Dog {     Person owner; }

In this diagram we enabled both relationship and dependency inference.
To make sure Person.dogs and Person.friends are interpreted as one to many relationship the collpackage option has to be specified.

Class Diagram Example: Schema

/*  * Schema model  * UML User Guide p. 112  */ /**  * @opt operations  * @opt attributes  * @opt types  * @hidden  */ class UMLOptions {} /* Define some types we use */ /** @hidden */ class Name {} /** @hidden */ class Number {} /**  * @has 1..* Member * Student  * @composed 1..* Has 1..* Department  */ class School {         Name name;         String address;         Number phone;         void addStudent() {}         void removeStudent() {}         void getStudent() {}         void getAllStudents() {}         void addDepartment() {}         void removeDepartment() {}         void getDepartment() {}         void getAllDepartments() {} } /**  * @has 1..* AssignedTo 1..* Instructor  * @assoc 1..* - 1..* Course  * @assoc 0..* - "0..1 chairperson" Instructor  */ class Department {         Name name;         void addInstructor() {}         void removeInstructor() {}         void getInstructor() {}         void getAllInstructors() {} } /**  * @assoc * Attends * Course  */ class Student {         Name name;         Number studentID; } class Course {         Name name;         Number courseID; } /**  * @assoc 1..* Teaches * Course  */ class Instructor {         Name name; }

Class Diagram Example: ER

I've used UMLgraph to generate an E-R diagram out of the DAOs we use in SQO-OSS. I've just annotated a few classes with @assoc tags, removed the super class DAObject from all entities with sed, did some tweaking by hand in the .dot output, et voila, an E-R depicting almost 30 classes in less than 30 minutes!

Class Diagram Example: Element Visibility

/**  * Attribute and operation visility  * UML User Guide p. 123  *  * @opt operations  * @opt attributes  * @opt types  * @opt visibility  * @hidden  */ class UMLOptions {} /** @hidden */ class Tool {} class Toolbar {         protected Tool currentSelection;         protected Integer toolCount;         public void pickItem(Integer i) {}         public void addTool(Tool t) {}         public void removeTool(Integer i) {}         public Tool getTool() {}         protected void checkOrphans() {}         private void compact() {} }

Class Diagram Example: Association Types

/**  * Associations with visibility  * UML User Guide p. 145  *  * @opt horizontal  * @hidden  */ class UMLOptions {} /** @assoc * - "*\n\n+user " User */ class UserGroup {} /** @navassoc "1\n\n+owner\r" - "*\n\n+key" Password */ class User{} class Password{}

Class Diagram Example: Real Example (Catalina Classes)

Class Diagram Example: Class Stereotypes and Tagged Values

/*  * Class stereotypes and tagged values  * UML User Guide p. 439  */ /**  * @opt attributes  * @opt operations  * @opt types  * @hidden  */ class UMLOptions {} /** @hidden */ class Action {} /**  * @stereotype container  * @tagvalue version 3.2  */ class ActionQueue {         void add(Action a) {};         /** @tagvalue version 1.0 */         void add(Action a, int n) {};         void remove(int n) {};         /** @stereotype query */         int length() {};         /** @stereotype "helper functions" */         void reorder() {}; }

Class Diagram Example: Fonts, Colors, Global and Local Options

/**  * @opt edgecolor "yellow"  * @opt nodefontname "Times"  * @opt bgcolor ".7 .9 1"  * @opt nodefillcolor "#a0a0a0"  * @opt nodefontsize 14  * @hidden  */ class UMLOptions{} /**  * @opt nodefontname "Helvetica-Bold"  * @opt nodefontcolor "white"  * @composed - - - Red  * @composed - - - Green  * @composed - - - Blue  * @opt attributes  * @opt visibility  * @opt types  */ class Pixel {         private int x, y;         public void setColor(ColorValue v) {} } /** @opt nodefillcolor red */ class Red {} /** @opt nodefillcolor green */ class Green {} /** @opt nodefillcolor blue */ class Blue {} /** @hidden */ class ColorValue{}

package net.sf.whatever.test; /**  * @hidden  * @opt postfixpackage  * @opt edgefontname arialbd  * @opt nodefontname arial  * @opt nodefontsize 9  * @opt nodefontabstract ariali  * @opt nodefontclassname arialbd  * @opt nodefontclassabstractname arialbi  * @opt nodefonttagsize 6  * @opt nodefonttagname ariali  * @opt nodefontpackagesize 8  * @opt operations  * @opt attributes  * @opt qualify  * @opt types  */ class UMLOptions{} /**  * @stereotype base  * @tagvalue since 1.0  */ abstract class AbstractBase {     /** @tagvalue since 1.5 */     private int field;     public abstract void abstractMethod();     public int concreteMethod() { return 1; } } /**  * @composed 1 has * from.Outer.Space.AlienClass  */ class Composite extends AbstractBase {} public class Style extends AbstractBase {}

Class Diagram Example: Multiple Views Through Command-Line Options

Class Overview

Detailed Class View

Java Description

Makefile

Class Diagram Example: Built-in Support for Views

• class: matches class names using a regular expression.
• subclass: first looks for the base classes using the specified regular expression, then matches the whole inheritance hierarchy of these classes. The base classes are included in the match as well.
• interface: first looks for interfaces using the specified regular expression, then matches every class that implements them, either directly or indirectly. The interfaces are included in the match as well.
• context: looks for classes using a regular expression, then matches every class that's directly connected to them.

The class match type is intended to be used with a regular expression, the others are usually performed against a class/interface name rather than a real regular expression, but the syntax allows for a regular expression to retain some flexibility (for example, a regular expression can be used to match multiple classes, as in "(A|B|C)").
Refer to the Pattern (http://java.sun.com/j2se/1.5.0/docs/api/java/util/regex/Pattern.html) API docs for details on regular expression specifications.

Matches will be evaluted in the order of specification, each applying its overrides to the current options. This means that options for a specific class are built in the following order, where each item overrides only the options specified locally, leaving the other options intact:

• Command line options
• UMLOptions options
• View options
• Match overrides, in the order they are specified, and only for the classes that satisfy the match conditions

Each view will generate a .dot file whose name is the name of the view, unless the "output" option is specified to override it. Along with the "-views" parameter on the command line, this allows for multiple views to be generated in a single doclet invocation.

View inheritance

When using view inheritance the option building order is:

• Command line options
• UMLOptions options
• Base view options
• View options
• Base view match overrides
• View match overrides

Class Diagram Example: Views With Different Specification Details

Class Diagram Example: Views for Different Packages

The CommonsDbcp view concentrates on the content of org.apache.commons.dbcp package, hiding other packages and subpackages available in the sources (click on the diagram to show a full size version).

Finally, the Statement view shows only the Statement related classes and their dependencies.

Running the Doclet from Ant

Notes

• When you pass the packagenames option to javadoc, the default (unnamed) package (and the UMLOptions class located in it) is ignored. In such cases you should include the UMLOptions class within a named package.
• The above invocation will generated a single class diagram. If multiple view generation is required you should add the views option.

Sequence Diagrams

The following is an example of a specification and the resulting UML sequence diagram:

.PS copy "sequence.pic"; # Define the objects object(O,"o:Toolkit"); placeholder_object(P); step(); # Message sequences active(O); step(); active(O); message(O,O,"callbackLoop()"); inactive(O); create_message(O,P,"p:Peer"); message(O,P,"handleExpose()"); active(P); return_message(P,O,""); inactive(P); destroy_message(O,P); inactive(O); # Complete the lifelines step(); complete(O); .PE

The diagram is drawn from its source code specification using a command like:

Syntax of Sequence Diagram Definitions

A sequence diagram file must start with the sequence:

Sequence diagram files must end with the sequence:

The sequence diagrams are defined by calling function-like pic macros. Each function call is terminated with a semicolon. Space is not significant between macro calls; on the other hand adding a space character between a macro's arguments can lead to surprises and should be avoided. Objects are referenced using variable-like alphanumeric identifiers. Strings are enclosed in double quotes.

As an example, the following defines an object O that will be identified in the diagram as o:Toolkit

Comments start with a # character.

Defining a Simple Sequence Diagram

1. Object definition
2. Message exchange
3. Object lifeline completion

The code then sends a messages from S to P labeled "run()", and another one labeled "stop()". Each message automatically advances the sequence diagram timeline by a single step.

Finally, the code completes the lifelines of the two objects.

The resultant diagram is

An Improved Sequence Diagram

The resultant diagram is

Creating and Destroying Objects

The following definition extends our previous diagram with a dynamically created flow object.

The resultant diagram is

Sequence Diagram Operations

object(name,label);

Defines an object with the given name, labeled on the diagram as specified.

placeholder_object(name)

Defines a place where the named object will later be created. Can also be written as pobject.

actor(name,label);

Defines an actor with the given name, labeled on the diagram as specified. Actors are typically used instead of objects to indicate operations initiated by human actions.

complete(name);

Completes the lifeline of a given object (or actor) by drawing its lifeline to the bottom of the diagram.

message(from_object,to_object,label)

Draws a message between two objects, with the given label. Self messages (where an objects sends a message to itself) are supported.

return_message(from_object,to_object,label)

Draws a return message between two objects, with the given label. Can also be written as rmessage.

create_message(from_object,to_object,object_label);

Has from_object create the to_object, labeled with object_label. The message is labeled with the «create» stereotype. Can also be written as cmessage.

destroy_message(from_object,to_object);

Sends a message labeled with the «destroy» stereotype from the from_object to the to_object. The object to_object is marked as destroyed, with an X at the end of its lifeline. The object's lifeline need not be otherwise completed. Can also be written as dmessage.

active(object);

Changes the object's status to active, and changes its lifeline drawing style correspondingly. An active call in an already active object will result in a swimlane showing a nested object activation.

inactive(object);

Changes the object's status to inactive, and changes its lifeline drawing style correspondingly. An inactive call on a nested object invocation will result in showing a simple active swimlane.

delete(object);

The object deletes itself, drawing an X at the end of its lifeline. The object's lifeline need not be otherwise completed.

lifeline_constraint(object,label);

Displays a constraint label (typically given inside curly braces) for the given object. The constraint will appear on the right of the object's lifeline at the time it appears. Can also be used to place an message label on the left of a message arrow, rather than its center. Can also be written as lconstraint.

lconstraint_below(object,label);

same as lconstraint, but it will be shown below the current line instead of above.

object_constraint(label)

Displays an object constraint (typically given inside curly braces) for the last object defined. Can also be written as oconstraint.

step();

Steps the time by a single increment, extending all lifelines.

async();

All subsequent messages are asynchronous and will be drawn correspondingly.

sync();

All subsequent messages are synchronous and will be drawn correspondingly.

begin_frame(left_object,name,label_text);

Begins a frame with the upper left corner at left_object column and the current line. The specified label_text is shown in the upper left corner.

end_frame(right_object,name);

Ends a frame with the lower right corner at right_object column and the current line. The name must correspond to a begin_frame's name.

comment(object,[name],[line_movement],[box_size] text);

Displays a comment about the object. The name can be used with connect_to_comment(object2,name); to get additional connecting lines to the comment. line_movement changes the position of the comment and box_size its size. Note that there's no comma between box_size and text. text is the (multiline) comment-text that will be displayed. name, line_movement and box_size are optional (but the commas must still appear).

connect_to_comment(object2,name);

See comment.

Sequence Diagram Variables

Variable Name	Default Value	Operation
boxht	0.3	Object box height
boxwid	0.75	Object box width
awid	0.1	Active lifeline width
spacing	0.25	Spacing between messages
movewid	0.75	Spacing between objects
dashwid	0.05	Interval for dashed lines
maxpswid	11	Maximum width of picture
maxpsht	11	Maximum height of picture
underline	1	Underline the name of objects

Sequence Diagram Example: Nested Activation and Complex Interactions

Diagram

Diagram Source Code

Sequence Diagram Example: Concurrent Processes and Activations

Diagram

Diagram Source Code

Sequence Diagram Example: Create and Destroy

Diagram

Diagram Source Code

Sequence Diagram Example: Lifeline Constraints

Diagram

Diagram Source Code

Sequence Diagram Example: External Actor

Diagram

Diagram Source Code

Sequence Diagram Example: A DNS Query

Diagram

Diagram Source Code

Sequence Diagram Example: A Comments and Frames

Diagram

Diagram Source Code

Frequently Asked Questions

Contents

• What is the command line sequence to generate a UMLGraph class diagram?
• Why are the SVG diagrams dot generates malformed?
• How can I improve the quality of the bitmap images I generate?
• How can I improve the layout of my class diagrams?
• A class appears multiple times in a class diagram. Why?
• Shouldn't static fields appear underlined?
• Where can I find a pic2plot executable for Windows?
• Under Windows the output of pic2plot appears empty. Why?
• I have a problem with Maven's Dotuml plugin. Can you help me?
• How can I make the UMLGraph doclet generate sequence diagrams?
• Why do the options specified in the UMLOptions class stop working, when I pass the packagenames option to javadoc?
• Why doesn't UMLGraph run under Mac OS X?
• Can I create UML class diagrams from C++ code?
• How can I get around a UMLGraphDoc crash with a ClassCastException?
• Under what license is UMLGraph distributed?
• Why do I get an exception java.lang.NoClassDefFoundError: com/sun/tools/javadoc/Main?
• How can I prevent clipped SVG images in sequence diagrams?
• How can I instruct UMLGraph to include private fields in its output?

What is the command line sequence to generate a UMLGraph class diagram?

Why are the SVG diagrams dot generates malformed?

How can I improve the quality of the bitmap images I generate?

One other possibility for converting the sequence diagram into Postscript is to pass it through pic and groff. Tools like ps2epsi and ps2eps can then be used to convert the Postscript into encapsulated Postscript. Of course, groff users will just use the pic program as part of their processing pipeline.

How can I improve the layout of my class diagrams?

A class appears multiple times in a class diagram. Why?

Problematic Specification

First Approach: Class Name Qualified with the Package

Second Approach: No Package Specification

Shouldn't static fields appear underlined?

Where can I find a pic2plot executable for Windows?

Under Windows the output of pic2plot appears empty. Why?

I have a problem with Maven's Dotuml plugin. Can you help me?

How can I make the UMLGraph doclet generate sequence diagrams?

Why do the options specified in the UMLOptions class stop working, when I pass the packagenames option to javadoc?

Why doesn't UMLGraph run under Mac OS X?

Can I create UML class diagrams from C++ code?

How can I get around a UMLGraphDoc crash with a ClassCastException?

JBuilder users need to go to Preferences/Build/Ant, and tick the box "Use project libraries when running ant" to solve the issue.

Under what license is UMLGraph distributed?

Why do I get an exception java.lang.NoClassDefFoundError: com/sun/tools/javadoc/Main?

How can I prevent clipped SVG images in sequence diagrams?

How can I instruct UMLGraph to include private fields in its output?

Bibliography

• Grady Booch, James Rumbaugh, and Ivar Jacobson. The Unified Modeling Language User Guide. Addison-Wesley, Reading, MA, 1999.

• Martin Fowler and Kendall Scott. UML Distilled: Applying the Standard Object Modeling Language. Addison-Wesley, Boston, MA, second edition, 2000.

• Emden R. Gasner, Eleftherios Koutsofios, Stephen C. North, and Kiem-Phong Vo. A technique for drawing directed graphs. IEEE Transactions on Software Engineering, 19(3):124–230, May 1993.

• Brian W. Kernighan. PIC—a graphics language for typesetting: Revised user manual. Computer Science Technical Report 116, Bell Laboratories, Murray Hill, NJ, December 1984. Available online at http://cm.bell-labs.com/cm/cs/cstr (http://cm.bell-labs.com/cm/cs/cstr).

• Object Management Group. Human-usable textual notation (HUTN) specification. Technical Report ptc/02-12-01, OMG Inc., Needham, MA, December 2002. Available online http://www.omg.org/docs/ptc/02-12-01.pdf (http://www.omg.org/docs/ptc/02-12-01.pdf).

• James Rumbaugh, Ivar Jacobson, and Grady Booch. The Unified Modeling Language Reference Manual. Addison-Wesley, Reading, MA, 1999.

• Frank Schoep. UML diagrams using Graphviz Dot, April 2006. Available online http://www.ffnn.nl/pages/articles/media/uml-diagrams-using-graphviz-dot.php (http://www.ffnn.nl/pages/articles/media/uml-diagrams-using-graphviz-dot.php).

• S. Seifermann and H. Groenda. Survey on textual notations for the unified modeling language. pages 28–39, 2016. cited By 0.

• Diomidis Spinellis. Code Reading: The Open Source Perspective. Addison-Wesley, Boston, MA, 2003.

• Diomidis Spinellis. On the declarative specification of models. IEEE Software, 20(2):94–96, March/April 2003.

• Diomidis Spinellis. Code Quality: The Open Source Perspective. Addison-Wesley, Boston, MA, 2006.

• Meera Subbarao. Reverse-engineer source code into uml diagrams, August 2008. Available online http://java.dzone.com/articles/reverse-engineer-source-code-u (http://java.dzone.com/articles/reverse-engineer-source-code-u).

Projects Based on UMLGraph

• Dotuml (http://maven-plugins.sourceforge.net/maven-dotuml-plugin/) integrates UMLGraph into Maven (http://maven.apache.org/).
• The Xholon (http://www.primordion.com/Xholon/index.html) framework for building loosely-organized systems captures object interactions at runtime, and creates UML 2.0 sequence diagrams using UMLGraph.
• phpCallGraph (http://phpcallgraph.sourceforge.net/) can output its analysis in UMLGraph format, allowing the automatic production of UML sequence diagrams from PHP code.
• LightUML (http://lightuml.sourceforge.net/) integrates UMLGraph into Eclipse (http://www.eclipse.org).
• ruby-uml (http://ruby-uml.rubyforge.org/) traces aspects of an application using UMLGraph to generate sequence and class diagrams.
• The Politecnico Di Torino SoftEng group has extended UMLGraph into the XUG (http://softeng.polito.it/projects/XUG/) reverse engineering tool.
• Adam Feuer's PyUMLGraph (http://www.python.org/pypi/PyUMLGraph) system applies the concept to Python programs.
• The MoinMoin (http://moinmo.in/) Wiki engine uses UMLGraph to provide support for UML sequence diagrams (http://moinmo.in/ParserMarket/UmlSequence).
• The Glean (http://jbrugge.com/glean/) framework for generating feedback on a team's source code supports the scripting of UMLGraph.
• W. Goesgens has documented here (http://wiki.ioslo.net/dokuwiki/graphviz#plugging_umlgraph_infront_of_graphviz) a way to use UMLGraph diagrams in DokuWiki (http://wiki.splitbrain.org/wiki:dokuwiki).
• Mykhaylo Sorochan has built on top of UMLGraph a higher-level domain-specific language for specifying UML sequence diagrams (http://macroexpand.org/doku.php/articles:uml-sequence-diagram-dsl-txl:start).
• Sketchlet (http://sketchlet.sourceforge.net/) is using UMLGraph as a widget plugin. You can find a video about the Sketchlet UMLGraph widget usage at http://www.youtube.com/watch?v=H6lrgSYyzE0 (http://www.youtube.com/watch?v=H6lrgSYyzE0).
• argouml-graphviz (http://argouml-graphviz.tigris.org/) is a plugin to let ArgoUML generate graphviz files.

Version History

Version 5.7 Under development

Version 5.6 2012-05-31

• Maven artifact deployment

Version 5.5 2012-05-13

• Added ability to make aggregate relationships (@has and @composed) navigable through the new @navhas and @navcomposed relationships. (Contributed by Alan Jeffrey.)
• Make UMLGraphDoc generation compatible with JDK 7 (Contributed by Stefano Martina.)
• Moved project's source code repository hosting to GitHub (https://github.com/dspinellis/UMLGraph).
• Various documentation improvements.

Version 5.4 2011-01-08

• Make the generation of diamond shapes compatible with GraphViz 2.27. (Contributed by Soraya Santana de la Fe.)
• Make the diagram elements appearing in HTML content clickable. (Contributed by Bernd Onasch.)
• Fix to ensure that class images only appear once. (Contributed by Zhigang Xie.)

Version 5.3 2010-05-24

• Sequence diagrams provide an option to specify whether objects are underlined or not.
• Documentation generated with UMLGraph will process correctly non-ASCII characters. (Fix contributed by Gunho Kim.)
• New -dotexecutable option allows the explicit specification of dot's location. (Contributed by Laird Nelson.)
• UmlGraphDoc will obey the options specified through @opt tags within Java files. (Contributed by Laird Nelson.)
• Use a logical font rather than a font file name for italics. This fixes a problem with unresolved fonts under Windows and modern versions of Graphviz. (Suggested by Przemyslaw Szufel.)
• Support for javadoc's -linkoffline option. (Contributed by Nikita Kozlov.)
• Do not show relations of hidden fields. (Fix contributed by Cimballi.)

Version 5.2 2008-12-03

• Corrected case of the tools.jar filename in the umlgraph shell script. (Reported by Øyvind Jergan).
• Fixed exception when an unknown class dependency is specified. (Reported by Jan Schlüter).
• Corrected NullPointerException occurring when no global options were available. (Fix supplied by Bernd Blacha.)

Version 5.1 2008-08-27

• Active classes now appear with a double vertical border, following UML2.
• Reorganized the documentation of class diagram options.
• New class diagram options -nodesep and -ranksep, which allow fine control of the generated diagram layout. (Patch submitted by Trustin Lee.)
• A class's title will appear as a tooltip in image files that support this feature. (Patch submitted by Anthony Callegaro.)
• Nested class hyperlinks to Javadoc documentation now work correctly. (Patch submitted by David P. Caldwell.)
• The guillemot characters are now output with their Unicode HTML numeric escapes instead of their HTML symbolic values. This makes the output work correctly on Mac OS X, and is also easier to validate with XML tools. (Patch submitted by Joshua Lim.)
• UmlGraphDoc now supports Javascript-collapsible UML diagrams. A new option -collapsible can be used to enable this feature. (Patch submitted by Franz Wilhelmstoetter.)

Version 5.0 2007-11-29

• All code now lives under org.umlgraph. This change requires corresponding modifications to the UMLGraph callers.
• Add support for six new shapes: node, component, package, collaboration, usecase, and activeclass. These shapes require GraphViz 2.16 or newer.
• A new @note tag allows the annotation of elements with comments. (Suggested by Sébastien Pierre.)
• A new @commentname option allows the naming of elements with the text of the javadoc comment.

Version 4.9 2007-09-28

• Note that from this version UMLGraph requires JDK 6.
• Added installation instructions.
• Improved documentation for invoking UmlGraph.
• Command-line scripts for invoking UmlGraph from Windows and Unix.
• Test data is now compatible with the output of the JDK 6 javadoc
• Java 6.0 deprecated methods are marked in the code as such.
• The -noguillemot option now outputs escaped characters compatible with version 1.13 of Graphviz. (reported by Roger Alexander).
• Fix inferred relations of maps to primitive Java types. (reported by Przemyslaw Wesolek).

Version 4.8 2007-05-10

• This is the last version compatible with Java 1.5.
• UmlGraph can now be invoked directly as a jar file.
• Support for sending results to the standard output for piping into dot.
• The distribution includes an example shell script and batch file for invoking UmlGraph.

Version 4.7 2007-03-26

• Correct the build file for generating the UmlGraph javadocs under Unix (Dirk Datzert)
• Correct output of UmlGraphDoc path-relative file names under Windows (fix by: Panagiotis Astithas)
• Fix InvocationTargetException when a relative output file name is given (reported by: Georgios Gousios)

Version 4.6 2007-02-05

• Portability fix so that UmlGraphDoc can now run again under Unix (bug introduced in version 4.5).
• Note: Image maps and the UmlGraphDoc tests will not work correctly with dot 2.12; see this GraphViz problem report (http://www.graphviz.org/bugs/b1069.html).

Version 4.5 2006-12-14

• Correct running of the UmlGraphDoc tests
• Correct the JavaDoc generation (Maxim Butov)
• Correct appearance of generic names (Ivan F. Villanueva B.)
• UmlGraphDoc now handles filenames with embedded spaces (reported and tested by Jörn Guy Süß and Christophe DENEUX)

Version 4.4 2006-07-19

• Major new functionality: UmlGraphDoc, a new doclet that can generate context and package class diagrams integrated with the standard javadoc output. Uses the same switches as UmlGraph. (Andrea Aime)
• Removed -verbose2 option, use the standard -quiet option instead to avoid UmlGraphDoc and UmlGraph printing notices. (Andrea Aime)
• Added a -inferdepvis option that allows to control which member of a class will be used for dependency inference. Acceptable values are private, package, protected and public. Makes sense when inferring dependencies without using -useimports.
• Added a -inferdepinpackage option that enables dependency inference among classes in the same package. This is disabled by default, since there is no reliable way to infer dependencies, and classes in the same package are supposed to be related anyway.
• Support the -link flag in the same way as the standard doclet, in order to populate the api doc map, used to generate image maps with links to associated external classes.
• Filter-out the static initializer method from classes (Andreas Studer)

Version 4.3 2006-03-05

• Now using HTML labels in dot files. This allows for a different font in each row of the class nodes. Added options to control fonts for class names, packages and tags. (Andrea Aime)

Version 4.2 (internal release)

• Correct the handling of qualified class names following the extends keyword (Arnaud Rogues).
• Relationship inference support. When enabled UMLGraph will try to compute relationships and dependecies by field/method/import statements examination. (Andrea Aime)
• Standard class lookup for association targets. The target can be specified by name without the need to include the full package information, imports and standard visibility rules will be applied to determine the actual class (Andrea Aime)
• A views feature provides the ability to specify option overrides for classes satisfying specific conditions and to generate multiple diagrams in a single doclet invocation. See the new tags @view, @match and the command line parameters -d, -view, -views (Andrea Aime)
• Options can be reset to their default value using the "@opt !option" syntax (useful for local overrides and in views) (Andrea Aime)
• Javadoc documentation (Andrea Aime).
• Centralized option handling in the Option class (even for command line arguments) (Andrea Aime).

Version 4.1 2005-11-15

• Major source code reorganization to move closer to the Java coding conventions. The user-visible change is that the doclet is now invoked as
  javadoc -docletpath UmlGraph.jar -doclet gr.spinellis.umlgraph.doclet.UmlGraph
  
• Show package visibility for class members (Olek Poplavskyy).
• Prevent crash when processing erroneous relation specifications (Andrea Aime).
• Most loops were refarctored to use the typesafe Java 1.5 foreach construct.
• Fix Eclipse warning (Andrea Aime).
• Better control of class hiding. Now classes are hidden even when involved in a relationship with a visible class (Andrea Aime).
• Source code modifications to allow Java-based testing (Andrea Aime).

Version 3.3 2005-10-19

• The sequence diagrams now include support for drawing comments and frames. (Contributed by Sebastian Setzer)
• The -noguillemot option will output two angle bracket pairs instead of round brackets around stereotypes.

Version 3.2 2005-07-19

• Display the template arguments of generic classes inside angle brackets. Note that according to the UML specification these arguments should be displayed in a dashed box on the top right of the class. However, such a display is currently not possible in GraphViz.
• Display the type parameters of fields and method arguments.

Version 3.1 2005-03-26

• Note that from this version UMLGraph requires Java 1.5.
• First step of the Java 1.5 transition; more will follow.
• The container code in the source was changed to use the Java 1.5 generics.
• Will display enumerations as a stereotyped primitive type. Two new options -enumerations and -enumconstants control the corresponding operation.

Version 2.10 2004-11-19

• This is the last version compatible with Java 1.4.
• Corrected the interaction between the -attributes and -operations options and classes with no fields or methods. Many thanks to Jonathan Wright for this contribution.
• New documentation look, designed by George Zouganelis

Version 2.9 2004-10-07

• Class diagrams can now include constructors, through the new -constructors option.

Version 2.8 2004-08-09

• Fixes to support the Maven plugin.
• From this version onward, use the appropriate options to create documentation links; no hyperlinks are created by default.

Version 2.7 2004-08-06

• The -noguillemot option will output round brackets around stereotypes, instead of angle brackets. The angle brackets appear to be breaking some programs.

Version 2.6 2004-08-03

• Note that from this version UMLGraph requires Java 1.4.
• Documentation example: multiple views from the same source. Many thanks to Vadim Nasardinov for this contribution.
• Documentation now includes a FAQ section.
• Documented the fact that package names must be explicitly specified in tags. Arne Bayer noticed the associated problem.
• Correct handling of multiple space in tags. Noted by Jeffrey M. Thompson which the help of FindBugs (http://findbugs.sourceforge.net/).
• Completed customization of URL mapping. Now the mapping is fully configurable and can be controlled by the use of two new options: "-apiDocRoot" and -"apiDocMapFileName". This change allows the creation of "clickable" diagrams fully integrated with web-based documentation (for example JavaDoc pages). The upcoming UMLGraph Maven plugin will take full advantage of this feature. Implementation contributed by Nascif Abousalh-Neto
• The -hide argument now accepts regular expressions.
• Removed copy-pasted Java code that was introduced in version 1.24.
• Some dot edges were missing a semicolon. This is now fixed.

Version 2.5 2004-06-15

The object swimlanes in a sequence diagram can now show nested object invocations. This very useful and non-trivial change was contributed by Jonathan R. Santos.

Version 2.4 2004-05-29

Will now generate local URL hyperlinks for packages specified in the command line; and links to the Sun documentation for all other packages. Many thanks to Nascif Abousalh-Neto for contributing this change.

Version 2.3 2004-05-27

• Remove hardcoded default node and edge fonts. Thanks to Vadim Nasardinov for submitting the corresponding patch.
• Generate javadoc hyperlink paths in a directory-tree structure; do not show arcs on hidden classes. Thanks to Alessandro Riva for submitting the corresponding patch.

Version 2.2 2004-05-25

SVG class diagrams containing guillemot characters for stereotypes can now be made valid through a new -outputencoding option. Use "-outputencoding UTF-8" when using dot to generate SVG diagrams. Many thanks to Nascif Abousalh-Neto for bringing this problem to my attention.

Version 2.1 2004-05-16

The guillemot characters used for the create and destroy stereotypes are now portable between groff and pic2plot. Many thanks to Scott Johnson (Duluth, MN) for recommending the change.

Version 2.0 2004-05-09

• Support for drawing sequence diagrams.
• New distribution format.
• Browsable and printable documentation.
• Removed the ant-based compilation and distribution system; it was proving a hindrance in organizing the project in a resonable manner. Compiling the documentation and distribution is now handled by a (non-distributed) Makefile; the compilation process is described in the README file.

Version 1.24 2003-07-30

Changes by Art Hampton (thanks):

• Create the appropriate label for relationship tags when referring to classes which were not parsed by javadoc.
• New "-hide <matchstring>" option, where <matchstring> matches the end of the name of an entity. Matched entities are removed from the graph. A regular expression matching facility will be added when Java 1.4 becomes more widespread.

Version 1.23 2003-05-7

Added -output command-line option, and an ant-based build file. Modified the dot output to avoid triggering a graphviz bug that made escape codes visible.

Version 1.20 2003-04-25

Fixes by Nick Efthymiou (thanks): will generate SVG hyperlinks to Javadoc documentation, better handling of abstract class fonts, and correct listing of interfaces.

Version 1.19 2002-09-20

New options: nodefontname, nodefontabstractname, nodefontsize, nodefontcolor, edgefontname, edgefontsize, edgefontcolor, edgecolor, bgcolor.

Version 1.18 2002-08-26

• Can now specify class-local options.
• Support for the @tagvalue tag.
• Support for the @stereotype tag.
• Added nodefillcolor option.

Version 1.15 2002-07-26

First public release.

Acknowledgements

UMLGraph was developed and is being maintained by Diomidis Spinellis (http://www.spinellis.gr). Andrea Aime has contributed the functionality for adding UML diagrams to javadoc pages, for inferring relationships, and for multiple diagram views.

In addition, the following individuals have contributed useful comments and code. UMLGraph would not be in its current state without their contributions.

• Nascif Abousalh-Neto
• Roger Alexander
• Panagiotis Astithas
• Bernd Blacha
• Yves Bossel
• Maxim Butov
• David P. Caldwell
• Anthony Callegaro
• Cimballi
• Dirk Datzert
• Christophe Deneux
• Nick Efthymiou
• Georgios Gousios
• Antti Hakala
• Art Hampton
• Alan Jeffrey
• Øyvind Jergan
• Scott Johnson
• Gunho Kim
• Nikita Kozlov
• Trustin Lee
• Joshua Lim
• Stefano Martina
• Vadim Nasardinov
• Laird Nelson
• Bernd Onasch
• Sébastien Pierre
• Olek Poplavskyy
• Alessandro Riva
• Arnaud Rogues
• Soraya Santana de la Fe
• Jonathan R. Santos
• Jan Schlüter
• Sebastian Setzer
• Jörn Guy Süß
• Andreas Studer
• Przemyslaw Szufel
• Ivan F. Villanueva B.
• Przemyslaw Wesolek
• Franz Wilhelmstoetter
• Zhigang Xie

• Contents

 Last change: Thursday, January 1, 1970 2:00 am
 Unless otherwise expressly stated, all original material on this page created by Diomidis Spinellis is licensed under a Creative Commons Attribution-Share Alike 3.0 Greece License.