• JUDE API
• JUDE API の利用
• 使用例

■JUDE API

• Jude については、"UML - モデリング・ツール (Jude)" を参照してください。

• JUDE APIは、JUDE のモデルデータを活用するアプリケーションソフトウェアを開発するための Java インターフェース群です。

• つぎのインターフェースがあります。
  • パッケージ (IPackage)
  • サブシステム (ISubsystem)
  • モデル (IModel)
  • クラス (IClass)
  • 属性 (IAttribute)
  • 操作 (IOperation)
  • 引数 (IParameter)
  • 関連 (IAssociation)
  • 関連クラス (IAssociationClass)
  • 依存 (IDependency)
  • 汎化 (IGeneralization)
  • 実現 (IRealization)
  • ユースケース (IUseCase)
  • 拡張 (IExtend)
  • 拡張点 (IExtentionPoint)
  • 包含 (IInclude)
  • タグ付き値 (ITaggedValue)
  • 制約 (IConstraint)
  • 多重度 (IMultiplicityRange)
  • コメント (IComment)

■JUDE API の利用

• Eclipse 上で利用するための設定です。

• ビルド･パスを設定します。

  • [プロジェクト]を右クリック - [ビルド･パス] - [外部アーカイブの追加] で、つぎの jar ファイルを選択します。
    • jude-api.jar
    • jude-community.jar

• JUDE API のドキュメントを指定します。

  • [プロジェクト] - [jude-api.jar]を右クリック - [プロパティ] - [Javadoc ロケーション] - [Javadoc URL]をチェック - [Javadoc ロケーション･パス] で、つぎのパス(Jude のインストールをデフォルトで行った場合) を指定します。
    • file:/C:/Program Files/JUDE-Community/api/doc/javadoc/

■使用例

• コマンドライン引数から Jude ファイルを入力し、そのパッケージとクラスの情報を表示するアプリケーション "JudeModelPrinterMain.java" を作成します。

  "IteratorPattern.jude"	Jude ファイル(デザイン･パターンの内、Iterator パターン)
  "JudeModelPrinterMain.java"	Jude ファイルを表示するアプリケーション
  "JudeModelPrinter.java"	Jude ファイルを表示するオブジェクトのクラス
  "JudeModelUtil.java"	Jude API を利用する上でのユーティリティ

  □ "IteratorPattern.jude"

  

  □ "JudeModelPrinterMain.java"

  
   public class JudeModelPrinterMain {
   
       public static void main(String[] args) {
   
           String inputFile = args[0];
           try {
               JudeModelPrinter sample = new JudeModelPrinter(inputFile);
               sample.execute();
               System.out.println("Done");
   
           } catch (Exception e) {
               e.printStackTrace();
               System.out.println("Failed");
           }
       }
   }
  
  

  □ "JudeModelPrinter.java"

  
   import java.io.IOException;
   import java.util.Arrays;
   
   import com.change_vision.jude.api.inf.exception.LicenseNotFoundException;
   import com.change_vision.jude.api.inf.exception.NonCompatibleException;
   import com.change_vision.jude.api.inf.exception.ProjectLockedException;
   import com.change_vision.jude.api.inf.exception.ProjectNotFoundException;
   import com.change_vision.jude.api.inf.model.IAttribute;
   import com.change_vision.jude.api.inf.model.IClass;
   import com.change_vision.jude.api.inf.model.IElement;
   import com.change_vision.jude.api.inf.model.IModel;
   import com.change_vision.jude.api.inf.model.INamedElement;
   import com.change_vision.jude.api.inf.model.IOperation;
   import com.change_vision.jude.api.inf.model.IPackage;
   import com.change_vision.jude.api.inf.project.ProjectAccessor;
   import com.change_vision.jude.api.inf.project.ProjectAccessorFactory;
   
   
   /**
    * Jude のプロジェクトのパッケージ、クラス情報を表示します。
    * @author maruno
    *
    */
   public class JudeModelPrinter {
   
       /**
        * 入力ファイル名。 
        */
       private String inputFile;
       
       /**
        * 入力するファイル名を使って、このインスタンスを生成します。
        * @param inputFile
        */
       public JudeModelPrinter(String inputFile) {
           this.inputFile = inputFile;
       }
   
       /**
        * プロジェクトを表示します。
        * @throws Exception 
        * @throws ProjectLockedException 
        */
       public void execute() throws ProjectLockedException, Exception {
   
               // プロジェクトを開いて、プロジェクトモデルを取得する
               ProjectAccessor prjAccessor = ProjectAccessorFactory.getProjectAccessor();
               try {
                   prjAccessor.open(inputFile);
               } catch (ProjectLockedException e) {
                   throw new ProjectLockedException();
               } catch (Throwable e) {
                   e.printStackTrace();
                   throw new Exception(e);
               }
               IModel iModel = prjAccessor.getProject();
               print(iModel, "project");
               System.out.println("----------------------------------------");
    
               printElements(iModel.getOwnedElements());
       }
   
       /**
        * プロジェクト内の名前付要素を再帰的に表示します。
        * ただし、先頭が "java" で始まるパッケージは除きます。
        * @param iNamedElements
        */
       private void printElements(INamedElement[] iNamedElements) {
           for (int i = 0; i < iNamedElements.length; i++) {
               INamedElement element = iNamedElements[i];
               if (element.getName().equals("java")) continue;
               print(element, element.getName());
   
               if (element instanceof IClass) {
                   print(((IClass) element));
               }
   
               System.out.println("----------------------------------------");
               if (element instanceof IPackage) {
                   printElements(((IPackage) element).getOwnedElements());
               }
           }    
       }
   
       /**
        * クラスの情報を表示します。
        * @param iClass
        */
       private void print(IClass iClass) {
           String name = iClass.getName();
           System.out.println(name + ".abstract             = " + iClass.isAbstract());
           System.out.println(name + ".active               = " + iClass.isActive());
           System.out.println(name + ".leaf                 = " + iClass.isLeaf());
           System.out.println(name + ".attributes           = " + JudeModelUtil.getNames(iClass.getAttributes()));
           System.out.println(name + ".operations           = " + JudeModelUtil.getNames(iClass.getOperations()));
           System.out.println(name + ".nestedClasses        = " + Arrays.asList(iClass.getNestedClasses()));
           System.out.println(name + ".generalizations      = " + JudeModelUtil.getNames(iClass.getGeneralizations()));
           System.out.println(name + ".specializations      = " + JudeModelUtil.getNames(iClass.getSpecializations()));
           System.out.println(name + ".supplierRealizations = " + JudeModelUtil.getNames(iClass.getSupplierRealizations()));
           System.out.println(name + ".clientRealizations   = " + JudeModelUtil.getNames(iClass.getClientRealizations()));
           System.out.println(name + ".fullName             = " + JudeModelUtil.getFullName(iClass));
           System.out.println("--------");
           
           print(iClass.getAttributes());
           System.out.println("--------");
           
           print(iClass.getOperations());
       }
   
       /**
        * 属性の情報を表示します。
        * @param iAttributes
        */
       private void print(IAttribute[] iAttributes) {
           for (int i = 0; i < iAttributes.length; i++) {
               IAttribute attribute = iAttributes[i];
               if (attribute.getName().length() == 0) continue;
               String type = "  " + ((INamedElement) attribute.getOwner()).getName() + "." + attribute.getName();
               print((INamedElement) attribute, type);
   //            System.out.println(type + ".type                 = " + attribute.getType().getName());
               System.out.println(type + ".typeExpression       = " + attribute.getTypeExpression());
               System.out.println(type + ".initialValue         = " + attribute.getInitialValue());
               System.out.println(type + ".changeable           = " + attribute.isChangeable());
               System.out.println(type + ".association          = " + ((attribute.getAssociation() != null) ? attribute.getAssociation().getName() : ""));
               System.out.println(type + ".qualifiers           = " + Arrays.asList(attribute.getQualifiers()));
               System.out.println(type + ".multiplicity         = " + JudeModelUtil.getMultiplicity(attribute.getMultiplicity()));
               System.out.println(type + ".derived              = " + attribute.isDerived());
               System.out.println(type + ".composite            = " + attribute.isComposite());
               System.out.println(type + ".aggregate            = " + attribute.isAggregate());
               System.out.println(type + ".enable               = " + attribute.isEnable());
               System.out.println(type + ".static               = " + attribute.isStatic());
               System.out.println("  ----");
           }
       }
   
       /**
        * 操作情報を表示します。
        * @param iOperations
        */
       private void print(IOperation[] iOperations) {
           for (int i = 0; i < iOperations.length; i++) {
               IOperation operation = iOperations[i];
               if (operation.getName().length() == 0) continue;
               String type = "  " + ((INamedElement) operation.getOwner()).getName() + "." + operation.getName() + "()";
               print((INamedElement) operation, type);
               System.out.println(type + ".parameters           = " + JudeModelUtil.getParameterList(operation.getParameters()));
   //            System.out.println(type + ".returnType           = " + operation.getReturnType().getName());
               System.out.println(type + ".returnTypeExpression = " + operation.getReturnTypeExpression());
               System.out.println(type + ".leaf                 = " + operation.isLeaf());
               System.out.println(type + ".abstract             = " + operation.isAbstract());
               System.out.println(type + ".static               = " + operation.isStatic());
               System.out.println("  ----");
           }
       }
   
       /**
        * 名前付要素を表示します。
        * @param iNamedElement
        * @param name
        */
       private void print(INamedElement iNamedElement, String name) {
           System.out.println(name + ".name                 = " + iNamedElement.getName());
           System.out.println(name + ".constraints          = " + Arrays.asList(iNamedElement.getConstraints()));
           System.out.println(name + ".supplierDependencies = " + JudeModelUtil.getNames(iNamedElement.getSupplierDependencies()));
           System.out.println(name + ".clientDependencies   = " + JudeModelUtil.getNames(iNamedElement.getClientDependencies()));
           System.out.println(name + ".definition           = " + iNamedElement.getDefinition());
           if(!(iNamedElement instanceof IModel))
           System.out.println(name + ".visibility           = " + JudeModelUtil.getVisibility(iNamedElement));
           print((IElement) iNamedElement, name);
       }
   
       /**
        * 要素を表示します。
        * @param iElement
        * @param name
        */
       private void print(IElement iElement, String name) {
           if(!(iElement instanceof IModel))
           System.out.println(name + ".owner                = " + ((INamedElement) iElement.getOwner()).getName());
           System.out.println(name + ".comments             = " + Arrays.asList(iElement.getComments()));
           System.out.println(name + ".stereotypes          = " + Arrays.asList(iElement.getStereotypes()));
           System.out.println(name + ".taggedValues         = " + JudeModelUtil.getTaggedValuesMap(iElement.getTaggedValues()));
       }
   }
  
  

  □ "JudeModelUtil.java"

  
   import java.util.ArrayList;
   import java.util.HashMap;
   import java.util.List;
   import java.util.Map;
   
   import com.change_vision.jude.api.inf.model.IClass;
   import com.change_vision.jude.api.inf.model.IDependency;
   import com.change_vision.jude.api.inf.model.IElement;
   import com.change_vision.jude.api.inf.model.IGeneralization;
   import com.change_vision.jude.api.inf.model.IMultiplicityRange;
   import com.change_vision.jude.api.inf.model.INamedElement;
   import com.change_vision.jude.api.inf.model.IParameter;
   import com.change_vision.jude.api.inf.model.IRealization;
   import com.change_vision.jude.api.inf.model.ITaggedValue;
   
   /**
    * Jude のプロジェクトの情報を取得するユーティリティ・クラスです。
    * @author maruno
    *
    */
   public class JudeModelUtil {
   
       /**
        * クラス名をフルパスで取得します。
        * 
        * @param iClass
        *            クラス
        * @return クラス名（フルパス）
        */
       public static String getFullName(IClass iClass) {
           StringBuffer sb = new StringBuffer();
           IElement owner = iClass.getOwner();
           while (owner != null && owner instanceof INamedElement && owner.getOwner() != null) {
               sb.insert(0, ((INamedElement) owner).getName() + "::");
               owner = owner.getOwner();
           }
           sb.append(iClass.getName());
           return sb.toString();
       }
       
       /**
        * 名前付要素の名前リストを取得します。
        * @param iNamedElements
        * @return 名前リスト
        */
       public static List getNames(INamedElement[] iNamedElements) {
           List names = new ArrayList();
           for (int i = 0; i < iNamedElements.length; i++) {
               INamedElement element = iNamedElements[i];
               names.add(element.getName());
           }
           return names;
       }
   
       /**
        * 汎化の名前リストを取得します。
        * @param iGeneralizations
        * @return 名前リスト
        */
       public static List getNames(IGeneralization[] iGeneralizations) {
           List names = new ArrayList();
           for (int i = 0; i < iGeneralizations.length; i++) {
               IGeneralization generalization = iGeneralizations[i];
               List m = new ArrayList();
               m.add(generalization.getName());
               m.add(generalization.getSubType().getName());
               m.add(generalization.getSuperType().getName());
               names.add(m);
           }
           return names;
       }
   
       /**
        * 実現の名前リストを取得します。
        * @param iRealizations
        * @return 名前リスト
        */
       public static List getNames(IRealization[] iRealizations) {
           List names = new ArrayList();
           for (int i = 0; i < iRealizations.length; i++) {
               IRealization realization = iRealizations[i];
               List m = new ArrayList();
               m.add(realization.getName());
               m.add(realization.getSupplier().getName());
               m.add(realization.getClient().getName());
               names.add(m);
           }
           return names;
       }
   
       /**
        * 多重度を取得します。
        * @param iMultiplicityRange
        * @return 多重度
        */
       public static List getMultiplicity(IMultiplicityRange[] iMultiplicityRange) {
           List m = new ArrayList();
           for (int i = 0; i < iMultiplicityRange.length; i++) {
               IMultiplicityRange range = iMultiplicityRange[i];
               String r = "[" + toMultiplicityString(range.getLower()) + ".." + toMultiplicityString(range.getUpper()) + "]";
               m.add(r);
           }
           return m;
       }
   
       /**
        * 多重度をあらわす文字列を取得します。
        * @param range
        * @return 多重度をあらわす文字列
        */
       public static String toMultiplicityString(int range) {
           switch(range) {
           case IMultiplicityRange.UNDEFINED:
               return "UNDEFINED";
           case IMultiplicityRange.UNLIMITED:
               return "*";
           default:
           }
           return String.valueOf(range);
       }
   
       /**
        * 引数情報を取得します。
        * @param iParameters
        * @return 引数の情報リスト
        */
       public static List getParameterList(IParameter[] iParameters) {
           List parameters = new ArrayList();
           for (int i = 0; i < iParameters.length; i++) {
               IParameter parameter = iParameters[i];
               List m = new ArrayList();
               m.add(parameter.getName());
               m.add(parameter.getTypeExpression());
               parameters.add(m);
           }
           return parameters;
       }
   
       /**
        * 依存の名前リストを取得します。
        * @param iDependencies
        * @return 名前リスト
        */
       public static List getNames(IDependency[] iDependencies) {
           List names = new ArrayList();
           for (int i = 0; i < iDependencies.length; i++) {
               IDependency dependency = iDependencies[i];
               List m = new ArrayList();
               m.add(dependency.getName());
               m.add(dependency.getClient().getName());
               m.add(dependency.getSupplier().getName());
               names.add(m);
           }
           return names;
       }
   
       /**
        * タグ値をマップとして取得します。
        * @param taggedValues
        * @return タグ値のマップ
        */
       public static Map getTaggedValuesMap(ITaggedValue[] taggedValues) {
           Map m = new HashMap();
           for (int i = 0; i < taggedValues.length; i++) {
               ITaggedValue value = taggedValues[i];
               m.put(value.getKey(), value.getValue());
           }
           return m;
       }
   
       /**
        * 可視性を文字列で取得します。
        * 
        * @param iNamedElement
        *            名前付き要素
        * @return 可視性
        */
       public static String getVisibility(INamedElement iNamedElement) {
           if (iNamedElement.isPackageVisibility()) {
               return "package";
           } else if (iNamedElement.isProtectedVisibility()) {
               return "protected";
           } else if (iNamedElement.isPrivateVisibility()) {
               return "private";
           } else if (iNamedElement.isPublicVisibility()) {
               return "public";
           }
           return "";
       }
   }
  
  

  □ 実行結果

  $ java JudeModelPrinterMain IteratorPattern.jude
  project.name                 = IteratorPattern.jude
  project.constraints          = []
  project.supplierDependencies = []
  project.clientDependencies   = []
  project.definition           = 
  project.comments             = []
  project.stereotypes          = []
  project.taggedValues         = {jude.profiles=<?xml version = "1.0" encoding = "ISO-8859-1" standalone = "yes"?>
  <umlProfiles>
   <umlProfile>
    <name>jude.profiles</name>
   </umlProfile>
  </umlProfiles>
  
  }
  ----------------------------------------
  jp.maruno.name                 = jp.maruno
  jp.maruno.constraints          = []
  jp.maruno.supplierDependencies = []
  jp.maruno.clientDependencies   = []
  jp.maruno.definition           = 
  jp.maruno.visibility           = public
  jp.maruno.owner                = IteratorPattern.jude
  jp.maruno.comments             = []
  jp.maruno.stereotypes          = []
  jp.maruno.taggedValues         = {}
  ----------------------------------------
  pattern.name                 = pattern
  pattern.constraints          = []
  pattern.supplierDependencies = []
  pattern.clientDependencies   = []
  pattern.definition           = 
  pattern.visibility           = public
  pattern.owner                = jp.maruno
  pattern.comments             = []
  pattern.stereotypes          = []
  pattern.taggedValues         = {}
  ----------------------------------------
  iterator.name                 = iterator
  iterator.constraints          = []
  iterator.supplierDependencies = []
  iterator.clientDependencies   = []
  iterator.definition           = 
  iterator.visibility           = public
  iterator.owner                = pattern
  iterator.comments             = []
  iterator.stereotypes          = []
  iterator.taggedValues         = {}
  ----------------------------------------
  Aggregate.name                 = Aggregate
  Aggregate.constraints          = []
  Aggregate.supplierDependencies = []
  Aggregate.clientDependencies   = []
  Aggregate.definition           = 
  Aggregate.visibility           = public
  Aggregate.owner                = iterator
  Aggregate.comments             = []
  Aggregate.stereotypes          = [interface]
  Aggregate.taggedValues         = {}
  Aggregate.abstract             = false
  Aggregate.active               = false
  Aggregate.leaf                 = false
  Aggregate.attributes           = []
  Aggregate.operations           = [iterator]
  Aggregate.nestedClasses        = []
  Aggregate.generalizations      = []
  Aggregate.specializations      = []
  Aggregate.supplierRealizations = [[, Aggregate, ConcreteAggregate]]
  Aggregate.clientRealizations   = []
  Aggregate.fullName             = jp.maruno::pattern::iterator::Aggregate
  --------
  --------
    Aggregate.iterator().name                 = iterator
    Aggregate.iterator().constraints          = []
    Aggregate.iterator().supplierDependencies = []
    Aggregate.iterator().clientDependencies   = []
    Aggregate.iterator().definition           = 
    Aggregate.iterator().visibility           = public
    Aggregate.iterator().owner                = Aggregate
    Aggregate.iterator().comments             = []
    Aggregate.iterator().stereotypes          = []
    Aggregate.iterator().taggedValues         = {}
    Aggregate.iterator().parameters           = []
    Aggregate.iterator().returnTypeExpression = void
    Aggregate.iterator().leaf                 = false
    Aggregate.iterator().abstract             = true
    Aggregate.iterator().static               = false
    ----
  ----------------------------------------
  ConcreteAggregate.name                 = ConcreteAggregate
  ConcreteAggregate.constraints          = []
  ConcreteAggregate.supplierDependencies = []
  ConcreteAggregate.clientDependencies   = []
  ConcreteAggregate.definition           = 
  ConcreteAggregate.visibility           = public
  ConcreteAggregate.owner                = iterator
  ConcreteAggregate.comments             = []
  ConcreteAggregate.stereotypes          = []
  ConcreteAggregate.taggedValues         = {}
  ConcreteAggregate.abstract             = false
  ConcreteAggregate.active               = false
  ConcreteAggregate.leaf                 = false
  ConcreteAggregate.attributes           = []
  ConcreteAggregate.operations           = [iterator]
  ConcreteAggregate.nestedClasses        = []
  ConcreteAggregate.generalizations      = []
  ConcreteAggregate.specializations      = []
  ConcreteAggregate.supplierRealizations = []
  ConcreteAggregate.clientRealizations   = [[, Aggregate, ConcreteAggregate]]
  ConcreteAggregate.fullName             = jp.maruno::pattern::iterator::ConcreteAggregate
  --------
  --------
    ConcreteAggregate.iterator().name                 = iterator
    ConcreteAggregate.iterator().constraints          = []
    ConcreteAggregate.iterator().supplierDependencies = []
    ConcreteAggregate.iterator().clientDependencies   = []
    ConcreteAggregate.iterator().definition           = 
    ConcreteAggregate.iterator().visibility           = public
    ConcreteAggregate.iterator().owner                = ConcreteAggregate
    ConcreteAggregate.iterator().comments             = []
    ConcreteAggregate.iterator().stereotypes          = []
    ConcreteAggregate.iterator().taggedValues         = {}
    ConcreteAggregate.iterator().parameters           = []
    ConcreteAggregate.iterator().returnTypeExpression = void
    ConcreteAggregate.iterator().leaf                 = false
    ConcreteAggregate.iterator().abstract             = false
    ConcreteAggregate.iterator().static               = false
    ----
  ----------------------------------------
  Itreator.name                 = Itreator
  Itreator.constraints          = []
  Itreator.supplierDependencies = []
  Itreator.clientDependencies   = []
  Itreator.definition           = 
  Itreator.visibility           = public
  Itreator.owner                = iterator
  Itreator.comments             = []
  Itreator.stereotypes          = [interface]
  Itreator.taggedValues         = {}
  Itreator.abstract             = false
  Itreator.active               = false
  Itreator.leaf                 = false
  Itreator.attributes           = []
  Itreator.operations           = [hasNext, next]
  Itreator.nestedClasses        = []
  Itreator.generalizations      = []
  Itreator.specializations      = []
  Itreator.supplierRealizations = [[, Itreator, CreateIterator]]
  Itreator.clientRealizations   = []
  Itreator.fullName             = jp.maruno::pattern::iterator::Itreator
  --------
  --------
    Itreator.hasNext().name                 = hasNext
    Itreator.hasNext().constraints          = []
    Itreator.hasNext().supplierDependencies = []
    Itreator.hasNext().clientDependencies   = []
    Itreator.hasNext().definition           = 
    Itreator.hasNext().visibility           = public
    Itreator.hasNext().owner                = Itreator
    Itreator.hasNext().comments             = []
    Itreator.hasNext().stereotypes          = []
    Itreator.hasNext().taggedValues         = {}
    Itreator.hasNext().parameters           = []
    Itreator.hasNext().returnTypeExpression = void
    Itreator.hasNext().leaf                 = false
    Itreator.hasNext().abstract             = true
    Itreator.hasNext().static               = false
    ----
    Itreator.next().name                 = next
    Itreator.next().constraints          = []
    Itreator.next().supplierDependencies = []
    Itreator.next().clientDependencies   = []
    Itreator.next().definition           = 
    Itreator.next().visibility           = public
    Itreator.next().owner                = Itreator
    Itreator.next().comments             = []
    Itreator.next().stereotypes          = []
    Itreator.next().taggedValues         = {}
    Itreator.next().parameters           = []
    Itreator.next().returnTypeExpression = void
    Itreator.next().leaf                 = false
    Itreator.next().abstract             = true
    Itreator.next().static               = false
    ----
  ----------------------------------------
  CreateIterator.name                 = CreateIterator
  CreateIterator.constraints          = []
  CreateIterator.supplierDependencies = []
  CreateIterator.clientDependencies   = []
  CreateIterator.definition           = 
  CreateIterator.visibility           = public
  CreateIterator.owner                = iterator
  CreateIterator.comments             = []
  CreateIterator.stereotypes          = []
  CreateIterator.taggedValues         = {}
  CreateIterator.abstract             = false
  CreateIterator.active               = false
  CreateIterator.leaf                 = false
  CreateIterator.attributes           = [aggregate, ]
  CreateIterator.operations           = [hasNext, next]
  CreateIterator.nestedClasses        = []
  CreateIterator.generalizations      = []
  CreateIterator.specializations      = []
  CreateIterator.supplierRealizations = []
  CreateIterator.clientRealizations   = [[, Itreator, CreateIterator]]
  CreateIterator.fullName             = jp.maruno::pattern::iterator::CreateIterator
  --------
    CreateIterator.aggregate.name                 = aggregate
    CreateIterator.aggregate.constraints          = []
    CreateIterator.aggregate.supplierDependencies = []
    CreateIterator.aggregate.clientDependencies   = []
    CreateIterator.aggregate.definition           = 
    CreateIterator.aggregate.visibility           = private
    CreateIterator.aggregate.owner                = CreateIterator
    CreateIterator.aggregate.comments             = []
    CreateIterator.aggregate.stereotypes          = []
    CreateIterator.aggregate.taggedValues         = {}
    CreateIterator.aggregate.typeExpression       = int
    CreateIterator.aggregate.initialValue         = 
    CreateIterator.aggregate.changeable           = true
    CreateIterator.aggregate.association          = 
    CreateIterator.aggregate.qualifiers           = []
    CreateIterator.aggregate.multiplicity         = []
    CreateIterator.aggregate.derived              = false
    CreateIterator.aggregate.composite            = false
    CreateIterator.aggregate.aggregate            = false
    CreateIterator.aggregate.enable               = true
    CreateIterator.aggregate.static               = false
    ----
  --------
    CreateIterator.hasNext().name                 = hasNext
    CreateIterator.hasNext().constraints          = []
    CreateIterator.hasNext().supplierDependencies = []
    CreateIterator.hasNext().clientDependencies   = []
    CreateIterator.hasNext().definition           = 
    CreateIterator.hasNext().visibility           = public
    CreateIterator.hasNext().owner                = CreateIterator
    CreateIterator.hasNext().comments             = []
    CreateIterator.hasNext().stereotypes          = []
    CreateIterator.hasNext().taggedValues         = {}
    CreateIterator.hasNext().parameters           = []
    CreateIterator.hasNext().returnTypeExpression = void
    CreateIterator.hasNext().leaf                 = false
    CreateIterator.hasNext().abstract             = false
    CreateIterator.hasNext().static               = false
    ----
    CreateIterator.next().name                 = next
    CreateIterator.next().constraints          = []
    CreateIterator.next().supplierDependencies = []
    CreateIterator.next().clientDependencies   = []
    CreateIterator.next().definition           = 
    CreateIterator.next().visibility           = public
    CreateIterator.next().owner                = CreateIterator
    CreateIterator.next().comments             = []
    CreateIterator.next().stereotypes          = []
    CreateIterator.next().taggedValues         = {}
    CreateIterator.next().parameters           = []
    CreateIterator.next().returnTypeExpression = void
    CreateIterator.next().leaf                 = false
    CreateIterator.next().abstract             = false
    CreateIterator.next().static               = false
    ----
  ----------------------------------------
  Done