The steps performed in analyzing a class

We saw from the index page that for each Java source, Jemos Clanker first delegates to the Java parser the job of externalizing a Java source class into one or more Tree objects. Still in the same page we saw that the order in which the Tree objects are then available is:

  • Package definitions
  • Import declarations
  • Javadoc comments
  • Class members (class, method, instance variable definitions)

In this section we'll see how a Tree representing a Java source class is processed by Jemos Clanker in order to extract the required information in a JavaBean-like structure (literally an instance of

Below you'll find a sequence diagram which illustrates what the class does:

This are the steps performed by the class:

  • To maintain the possibility of 'programming by interfaces' I had to design all Lyrinx so that these accept a generic object as parameter. If one wants to be able to access all the instance methods offered by specific Tree objects (such as the one representing a class), this object needs to be narrowed to the appropriate sub-type. So the first thing the ClassLyrinx.process() method does is to narrow down the[some-object] to an instance of
  • It then asks the to create the bean-like class which represents the object that Jemos Clanker offers to the external world as a representation of a Java source class: an instance of
  • The method then sets the class name as instance variable in the Clazz object. This name is just the class name, not the fully qualified name, for which another instance variable is separately set (see below).
  • The method then retrieves from the Amplimet the Jemos Clanker object parent of this class thus an instance of, compose the fully qualified name of the class by appending to the package name the class name and sets this name as instance variable in the Clazz object.
  • If you went through the paragraph which explained where a class gets processed, you probably remember that the ThapterImpl.fillTheAmplimet() method, before actually starting the process of the Class part of the Tree object, deals with imports and Javadoc and that, for each class, fills the imports and Javadoc instance variables in the ThapterImpl class so that processors (Lyrinx) down the line will be able to access those information. This is exactly what happens here. Before the ClassLyrinx.process() method is invoked, imports and Javadocs have already been processed and made available in the ThapterImpl class as instance variables. This method then retrieves the Javadocs from the ThapterImpl class, selects only those relevant to this class (to exclude the ones related to inner classes) and sets those comments as instance variables in the Clazz object. As you can see, every action in this like in all other Lyrinx is to set the state of a object so as to make it available for clients.
  • The method then loops through all the interfaces implemented by this class and sets these in a collection of String objects containing the fully qualified name of those interfaces.
  • The method then loops through the Tree.[some-object] objects, children of a class (like methods and instance variables, but also inner classes) and for each one of them invokes the appropriate Lyrinx, which creates an instance of and sets it as children of the Clazz component.
  • The method then sets the class modifiers in a collection of String objects. Modifiers are strings like 'public', 'static', etc.
  • The method then asks the a processor for Annotations and invokes its process() method passing as parameter the Tree.Annotation object as parameter. It then adds each annotation returned by the processor to the Clazz object.

A object has to offer the following attributes:

  • Annotations, represented by a collection of objects.
  • Javadocs, represented by an instance of the class.
  • The class fully qualified name (package name + class name)
  • The list of implemented interfaces, represented by a collection of Strings
  • The inner classes, represented by a collection of objects
  • The list of methods, represented by a collection of classes
  • The list of modifiers, contained in a collection of Strings
  • The class name
  • The unique id of the parent class, containing the hashcode of the parent of this class
  • The instance and class variables, contained in a collection of class