The jmove wiki is main source for information concerning jmove. It contains more, detailed information including a tutorial on jmove.
The swing appplication jmover contains an user guide, describing its functionality and its user interface in detail.
The jmove distribution contains analysis reference documentation. Excerpts from this are described here to give a crude overview on the jmove model. Understanding the model is an essential step in using jmove.
The framework jmove provides one model, which offers basic elements to present an abstract view to software systems. This model is also called core model . The term core model is explicitly chosen to make a difference between the term meta model defined by OMG. In spite of OMG Meta-Model-Levels every jmove model is described by the same elements. To map for example a concrete Java Software System into a model, jmove provides principally the same structures like the core model. The concrete structure elements for Java are specializations from the core structure elements, but the type of the elements is the same.
In the context of jmove a model is a tupel of two sets. The first set contains elements describing model entities, an element of the this set is called Thing. The second set contains elements describing the connection between the model entitites. In detail the elements of the second set are itself tupels consisting of Things. An element of the second set is called Link. In a more abstract view a jmove model is an undirected graph consisting of nodes and edges, where the nodes are called Things and the edges are called Links.
A Thing has an identifer. Things can be added to a model and can be retrieved from a model by specifying its identifier. Additionally a model can deliver subsets of Things by specifying a Filter for things. Furthermore a Thing is a Linkable. A Linkable can be connected to a Link. A Link connects two and only two Linkables. The concrete implementation vary from the above abstract view, because Links are not directly retrieved from the model. The usage of LinkFilters to get subsets of Things by traversing all suiting links transitively from a given Thing gives many opportunities to inspect a model. Finally every Thing may be extended by one or more Aspects. An Aspect is associated to one thing and can be defined arbitrarily.
A model for programming language Java is described by a JModel. To build a java model physical resources like byte code or source code are used. One or more resources are grouped in Modules. A java package is defined by the construct JPackage. A package is a Thing and has a unique name (its absolute package path), which it is its identifier too. A package can contain classes and interfaces, which are collective represented by a Type. A Type is a Thing with additional modfiers. These modifiers marks properties like changeabilty or scope of a Type. The fact that a Type represents a class or a interface is also stored in the modifiers. The full qualified classpath of a class or an interface is the identifier of the representing type. For inner, local and anonymous types the identifiers are built by the same rules the compiler uses.
Furthermore types can haveMembers. A Member is an Attribute or a Method. Because members are ordinary things, they have an identifier. The identifier of a member is assembled by the identifier of the surrounding type, the character '.' and the name of the member. A specific feature of the language Java is the existence of primitives like int, double and boolean. In a
jmove java model a Primitive is a thing, so there is no much difference to a type. The identifier of an Primitive is its unique name, one of the following: boolean, byte, char, short, int, long, float, double. To fully support java, a jmove model can also contain arrays. An Array is a thing, with a reference to an element type and a dimension count. The identifier of an Array is the concatenation of the the identifier of its element type and per every dimension one ''.
While the aboved terms covers the structures in a java model, the following terms names the connectivity between these model elements.The link types
• Inheritance with the roles Supertype and Subtype,
• Dependency with the roles Target and Dependent,
• Containment with the roles Container and Element
• Usage with the roles Using and UsedBy
are supported by a jmove java model. At present the link ends have no cardinality, so if you have a dependency from type X to type Y, X can depend one or a hundred times on Y.
The diagram above shows the different Link-Types and their relation. Inheritance is a specialized Dependency, but Containment not. Usage is not a Dependency, too.
jmove offers the following aspects of a Thing:
- LoadState - Internal state for loading (unload, load, stub).
- Location - Place where the attached Thing was found.
- LineCount - Number of lines of the attached Thing.
- MaxBlockDepth - Maximum block depth (maximum number of open curly braces) of the attached Thing.
- SwallowedEceptionAspect - Pointing to source fragments containing catch-blocks, which will not forward or handle the corresponding exception.
- RCMartin - Abstractness, instability, distance, efferent and afferent coupling as defined by R.C.Martin of the attached type.
- ModelInfo - Simple count metrics for models.
- ModuleInfo - Simple count metrics for modules.
- JarClassCollection - The module location of the attached thing.
- DirClassCollection - The module location of the attached thing.