2. How Classycle works

1. Reading the class files
2. Creating the dependency graph of classes
3. Creating the dependency graph of packages
4. Detecting cycles
5. Calculating layer indices
6. Writing a report

2.1 Reading the Class Files

2.2 Creating the Dependency Graph of Classes

• Class constant: Refers to a UFT8 constant which contains the fully-qualified class name with '/' instead of '.' as package name separator.
• UFT8 constant: Contains an arbitray unicode-encoded string.
• String constant (optionally): Refers to a UFT8 constant which contains a string constant from the Java code.

class SimpleClass {
  String a;
}

If the commandline option -reflectionPattern is used also string constants in the pool are analysed. A string constant (as it appears in the code of a Java file) is handled as a class name if the following two conditions are fulfilled:

1. The string is a syntactically valid fully-qualified class name.
2. The string matches one of the specified patterns.

Note, that this reflection option is a must if a class with the following line of code should have a reference to java.lang.Thread:

Class clazz = Thread.class;

This analysis leads to a direct dependency in the following cases:

• Superclass.
• Field type.
• Classes of parameters and return value of any method declared or invoked.
• Class implementing an invoked method.
• String constants if the reflection option is used and the above-mentioned conditions are fulfilled.

• Local variables which are never used.
• Constants (i.e., static final declared fields) which can by resolved at compile time.

Examples:

class MyException 
          extends Exception {
  int left = java.awt.Label.LEFT;
  MyException(String msg) {
    super(msg);
    Integer n = null;
  }
}

class ExampleClass {
  int[] counts = new int[5];
  String[][] table
      = new String[5][3];
}

class ExampleClass {
  boolean atLeastOneSystemProperty
      = System.getProperties()
              .keys()
              .hasMoreElements();
}

abstract class 
    ExampleClass<T extends Set<Byte>> 
          implements Collection<Short>
{ 
  T handle(Map<Long, 
               ? extends Float[]> map) 
  { 
    return null;
  }
}	

(Ljava/util/Map;)Ljava/util/Set;
(Ljava/util/Map<Ljava/lang/Long;
   +[Ljava/lang/Float;>;)TT;
<T::Ljava/util/Set
      <Ljava/lang/Byte;>;>
   Ljava/lang/Object;
   Ljava/util/Collection
      <Ljava/lang/Short;>;

After the analysis of the constant pools of all read class files Classycle creates a directed graph (short: digraph): Each vertex represents an analysed class. Vertices are connected by directed edges (usually represented by an arrow). A directed edge will be pointed from vertex A to vertex B if Classycle has detected that A is refering B. The edge is called an outgoing arc for A and an incoming arc for B. In general they will be outgoing arcs to external classes which are not in the set of classes analysed by Classycle. These outgoing arcs will be ignored in step 4 and 5 of the analysis.

2.3 Creating the Dependency Graph of Packages

2.4 Detecting Cycles

The condensation leads to a new digraph where each vertex is a strong component of the original digraph. A directed edge goes from strong component a to b if a directed edge goes from at least one vertex of a to at least one vertex of b.

Note, that the detection of package cycles done by JDepend can be wrong. For example, JDepend would identify by mistake vertex C in the above-mentioned graph as cyclic. The reason is presumably that JDepend walks through the graph until it detects a vertex already visited. In this case it marks the starting vertex as cyclic.

2.5 Calculating Layer Indices

Grouping the classes of an application in layers suggests a layered architecture of the application. In general this is not the case. The layers introduced by the analysis of Classycle are of finer granularity and they violates in general the rule that a layer should only know the layer one level deeper. This rule would forbid the arrows from d to b and c in the example.

To get a layering in this strict sense one should do a further condensation by grouping the strong components in such a way that all edges pointing from a vertex with layer index n to a vertex with index n-1. Unfortunately, there is in general no unique way to do this. For example, one can condense the above example further by forming two groups: One group contains d and the other one c. But a and b may be both either in the d or c group or a in the d group and b in the c group.

2.6 Writing a Report