ontomde-java 2.0.0

data/lib/ontomde-java/java/java.rb

@@ -0,0 +1,1329 @@
+#:include: java.rdoc
+#:include: java_todo.rdoc
+
+require 'pathname'
+
+module Mjava_Annotation
+  rdf_safe_attr_reader_many :java_annotation
+  def java_writeAnnotation
+    mtk_protected(Mrdf_Resource::NOREVERSE,'annotations',context[:hasGlobalReverse]) {
+      java_annotation.each {|a|
+        write(a)
+        write("\n")
+      }
+      write("@Override\n") if (self.kind_of?(Muml_Operation) && !umlx_redefinesMethod.empty? && !umlx_redefinesMethod_one.umlx_owner_one.kind_of?(Muml_Interface) )
+    }
+  end
+  
+  def java_writeParamAnnotation(numParam='')
+
+    ext_isReferencedBy.each { |o|
+      if ( o.kind_of?(Muml_Operation) ) then
+        o.mtk_protected(Mrdf_Resource::NOREVERSE,'annoparam'+numParam,context[:hasGlobalReverse]) {
+          java_annotation.each {|a|
+            write(a)
+            write("\n")
+          }
+        }
+        return
+      end
+    }
+  end
+  
+  def java_writeMdatkAnno(zonesId=['annotations'])
+    mtk_annotation(Mrdf_Resource::NOREVERSE,zonesId)
+  end
+end
+
+
+
+module Muml_EnumerationLiteral
+  include Mjava_Annotation
+  
+  #List of initialisation parameter for this literal.
+  rdf_safe_attr_reader_many :java_initParameterValue
+  
+  def java_write
+    java_writeJavadoc
+    java_writeAnnotation
+    java_writeMdatkAnno(['javadoc','annotations']) if context[:hasGlobalReverse]
+    write(java_Name)
+    if !java_initParameterValue.empty?
+      sep=("(")
+      java_initParameterValue.each {|v|
+        write(sep) ; sep=","
+        write(v)
+      }
+      write(")")
+    end
+  end
+end
+
+module Muml_Parameter
+  include Mjava_Annotation
+  
+  # extension metamodele
+  rdf_safe_attr_reader_many :uml_qualifier
+  #rdf_safe_attr_reader_many :umlx_qualifier
+
+  #write java parameter declaration
+  # (Uses java_propertyRoleType, java_Name)
+  # parameter is declared final if direction is in (not out, not inOut)
+  #Example:
+  #* int x
+  #* final int x
+  #* String z
+  def java_write
+    write("final ") if uml_direction_one.isIn? # the best we can do with java
+    write("#{java_propertyAssociationType} ")
+    #write(" /* #{uml_lowerValue}..#{uml_upperValue}*/ ")
+    write(" #{java_Name}") unless uml_direction_one.isReturn?
+  end
+end
+
+
+module Muml_Stereotype
+  def getRubyStereotypeName
+    return uml_name.to_s.tr('^a-zA-Z0-9','_')
+  end
+
+  #return true if java generator should totaly ignore this element.
+  #
+  #NOTE:
+  #* Always returns true
+  def java_ignoreMe?
+    return true;
+  end
+end
+
+
+module Mrdf_Repository
+
+  # Example
+  # java_addJavaFilePathMapping(/\.example/,"src/main/example/" ])
+  #TODO: add helping error if jfp.nil?
+  def java_addContextJavaFilePathMapping(qualifiedNameRegexp,relativePath)
+    jfp=context[:javaFilePathRegexp]
+    jfp[qualifiedNameRegexp,relativePath]
+  end
+
+  def umlx_processStereotypes!
+    return
+    each { |k,c|
+      next unless c.kind_of?(Muml_Stereotype)
+      #log.debug "Registering stereotype #{c.getRubyStereotypeName}"
+      eval %{
+			module ::Muml_Stereotype_#{c.getRubyStereotypeName}
+			end
+      }
+    }
+    each {|k,c|
+      next unless c.kind_of?(Muml_Element)
+      next if c.appliedStereotype.empty?
+      appliedStereotype.each { |s|
+        c.class_eval %{
+
+        }
+      }
+    }
+
+  end
+
+  #trigger Muml_Classifier java_transform! for every class element
+  def java_transform!
+    #must copy before transformation (hash modified runtime error)
+    a=Array.new
+    each { |k,c|
+      next if c.kind_of?(Muml_Stereotype)
+      next unless c.kind_of?(Muml_Class) || c.kind_of?(Muml_Interface)||c.kind_of?(Muml_Enumeration)
+      a << c
+    }
+    a.each {|c|
+      c.java_transform! unless c.java_ignoreMe?
+    }
+
+    #java_addPersistence!
+    umlx_processStereotypes!
+  end
+
+  #Main java generator entry point.
+  #Triggers the generation of every Java file for the model.
+  def java_generateRepository
+    uml_Model_all.each {|m|
+      m.java_generateModel
+    }
+  end
+end
+
+module Muml_Model
+  def java_generateModel
+    mtk_default_context(:java_generateSetAttributeInitializer=>true) {
+      uml_Class_all.each {|c|
+        #next if c.kind_of?(Muml_Stereotype)
+        next unless c.kind_of?(Muml_Class) || c.kind_of?(Muml_Interface)||c.kind_of?(Muml_Enumeration)
+        # only generate if requested to do so
+        # usefull for generating separtely tests dans model
+        next if c.java_isATestFile? && !context[:includeTestFiles]
+        next if (!c.java_isATestFile?) && context[:excludeNonTestFiles]
+        c.java_generateClassifier
+      }
+      if context[:generateComponent]
+        uml_Component_all.each  { |c|
+          c.java_generateClassifier
+        }
+      end
+    }
+  end
+end
+
+#module Muml_Property
+#	def java_Name
+#		return uml_isStatic? ? super.upcase : super
+#	end
+#end
+
+module Muml_NamedElement
+  # true if name contains a generic.
+  rdf_safe_attr_reader_many :java_isGeneric
+
+  JAVA_RESERVED_WORD=["abstract", "boolean", "break", "byte", "case", "catch", "char", "class", "const", "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float", "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native", "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp", "super", "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void", "volatile", "while"]
+  JAVA_NUMBERS=["0","1","2","3","4","5","6","7","8","9"]
+  #returns a valid java symbol computed from str
+  #
+  #NOTE:
+  #
+  # display a warning an return /*TODO ...*/ if str is empty
+  #
+  #Examples:
+  # java_safeName("number") returns number
+  # java_safeName("8number")  returns _number
+  def java_safeName(str)
+    if str.empty?
+      log.warn "WARNING: blank name detected for obj type #{self.class.name} identified by uri=#{uri}"
+      return "/*TODO: ERROR:blank name found in uml model:*/"
+    end
+    #TODO A g?rer globalement pour la gestion des g?n?riques
+    if java_isGeneric?
+      # a generic may contain names such as xyz<org.myname>
+      ret=str.to_s.tr('^a-zA-Z0-9_<?>.,',"")
+    else
+      ret=str.to_s.tr('^a-zA-Z0-9_',"")
+    end
+    ret="_"+ret if JAVA_NUMBERS.include?(ret[0,1])
+    ret="_"+ret if JAVA_RESERVED_WORD.include?(ret)
+    return ret
+  end
+
+  #java unique name enforcement variable
+  JAVA_UNIQUE_NAME=Hash.new
+
+  #return a unique name for this element.
+  #Logs an error messge is uniqueness is not verified.
+  def java_uniqueName
+    ret=java_Name.to_s
+    k=JAVA_UNIQUE_NAME[ret]
+    if k.nil?
+      JAVA_UNIQUE_NAME[ret]=rdf_uri
+    elsif k!=rdf_uri
+      log_error_unique_name
+    end
+    return ret
+  end
+
+  def log_error_unique_name
+    #return if log_already_displayed?("#{rdf_uri}__uniqueName")
+    log.error {
+      <<END
+non unique name detected
+********* INVALID DATA DETECTED **********
+** This software expects uml names to be globaly unique.
+** The following item has been detected to be an homonym
+** of a previously processed model element.
+** #{mtk_object_message}
+**
+** Check your model and make sure names are unique.
+**
+** This model element is related to these other model elements:
+#{mtk_related_message}
+********* INVALID DATA DETECTED **********
+END
+    }
+    if context[:java_failIfNonUniqueName]
+      raise Warning.new(),"unique name assertion failed"
+    end
+
+  end
+
+  #Returns this element uml_name after applying java_safeName on it.
+  @java_Name_cache=nil
+  def java_Name
+    return @java_Name_cache unless @java_Name_cache.nil?
+    s=java_safeName(uml_name.to_s)
+    b=context[:java_fixNameCase,true]
+    if !b
+      # do nothing
+    elsif kind_of?(Muml_Package) || kind_of?(Muml_Property) || kind_of?(Muml_Parameter) || kind_of?(Muml_Operation)
+      if s[0..0].downcase!=s[0..0]
+        s="#{s[0..0].downcase}#{s[1,s.length]}"
+        display_java_Name_case_error(true)
+      end
+    elsif (kind_of?(Muml_Class) || kind_of?(Muml_Interface) || kind_of?(Muml_Enumeration) ) && ! kind_of?(Muml_PrimitiveType)
+      if s[0..0].capitalize!=s[0..0]
+        s="#{s[0..0].capitalize}#{s[1,s.length]}"
+        display_java_Name_case_error(false)
+      end
+    end
+    @java_Name_cache=s
+    return @java_Name_cache
+  end
+  #DISPLAY_JAVA_NAME_CASE_ERROR=Set.new()
+  def display_java_Name_case_error(isDowncase)
+    return unless context[:java_display_case_errors,false]
+    #next if DISPLAY_JAVA_NAME_CASE_ERROR.include?(self)
+    #DISPLAY_JAVA_NAME_CASE_ERROR<< self
+    log.error { %{***** INVALID MODEL DETECTED *****
+***** INVALID MODEL DETECTED *****
+Model element name:
+	uml_class=#{self.class.name}
+	rdf_uri=#{rdf_uri}
+	uml_name=#{uml_name}
+	uml_owner=#{umlx_owner_one}
+should begin with a #{isDowncase ? "downcase": "upcase"} character.
+***** INVALID MODEL DETECTED *****
+      }}
+  end
+
+
+  #Returns this element java_Name after applying a simplified java bean case convention.
+  #http://java.sun.com/products/javabeans/docs/spec.html
+  #anIntAttribute --> AnIntAttribute
+  #aBooleanAttribute --> aBooleanAttribute
+  def java_NameBean
+    return java_toNameBean(java_Name.to_s)
+  end
+  def java_toNameBean(name)
+    #special case handling introduced for struts
+    return name if name[1,1].upcase==name[1,1]
+    name=String.new(name)
+    name[0] = name[0, 1].upcase
+    return name
+  end
+
+  #Returns this element java_Name after applying a simplified java bean property case convention.
+  def java_NameProperty
+    return java_Name
+    #return java_toNameProperty(java_Name)
+  end
+
+  #Converts string name to a property name and returns its value.
+  #
+  #Example:
+  #   java_toNameProperty("Xyz") return "xyz"
+  #   java_toNameProperty("XYZ") return "xYZ"
+  def java_toNameProperty(name)
+    result = String.new(name)
+    if !result.empty?
+      result[0] = result[0, 1].downcase
+    end
+    return result
+  end
+end
+
+module Muml_Namespace
+
+  def java_getContextJavaFilePath(default=nil)
+    n=java_qualifiedName.to_s
+    jfp=context[:javaFilePathRegexp,nil]
+    return default if jfp.nil?
+    jfp.each { |mapping|
+      if n =~ mapping[0]
+        return context[:targetDir]+"/"+mapping[1]
+      end
+    }
+    return default
+  end
+  # Returns the path where to generate file for this object.
+  #
+  # NOTE:
+  # * Root directory is taken from context[:javaDir] (cf: mtk_context)
+  #
+  # Examples (with context[:build] equals to "build/":
+  # * build/package1/package2
+  # * build/package1/package2/UneClasse.java
+  def java_FilePath
+    return java_getContextJavaFilePath(context[:javaDir])+java_InternalFilePath
+  end
+
+  # Returns the internal path where to generate file for this object.
+  #
+  # NOTE:
+  #
+  # Examples
+  # *package1/package2
+  # *package1/package2/UneClasse.java
+  def java_InternalFilePath
+    r=""
+    umlx_sub_hierarchy.each { |n|
+      r+=n.java_Name
+      r+="/"
+    }
+    return r
+  end
+
+  #Returns this element java qualified name
+  #
+  #Example:
+  #  package1.package2.AClassClasse
+  #  AClassInRootDefaultPackage
+  #  package1.package2
+  def java_qualifiedName
+    r=sep=""
+    umlx_hierarchy.each { |n|
+      r+=sep
+      r+=n.java_Name
+      sep="."
+    }
+    return r
+  end
+
+  #List of namespaces to be ignored by generator.
+  #
+  #NOTE:
+  #* user may add its own item int the list.
+  #* list may contain package or class qualified names.
+  #
+  #EXAMPLE:
+  #* "org.xyz" will ignore every item under org.xyz
+  #* "org.xyz.ClassZ" will ignore only ClassZ
+  JAVA_IGNORE_NAMESPACE=["java.", "javax.", "xmda.bpm.api", "ontomde.bpm", "xmda.common","org.acegi"]
+
+  #return true if java generator should totaly ignore this element.
+  #
+  #NOTE:
+  #* returns true if this class name is in JAVA_IGNORE_ROOT_PACKAGE_NAME
+  def java_ignoreMe?(ignoreExternal=true)
+    #puts "ignore=#{self.class} #{self.uml_name}"
+    qn=java_qualifiedName
+    return true if umlx_hasStereotype?("nocode")
+    return true if umlx_external? && ignoreExternal 
+    JAVA_IGNORE_NAMESPACE.each { |ns|
+      return true if qn.index(ns)==0
+    }
+    return false;
+  end
+end
+
+module Muml_VisibilityKind
+  #returns java visibility modifiers (public/protected/private/package)
+  def java_visibilityModifiers
+    return "public " if isPublic?
+    return "protected " if isProtected?
+    return "private " if isPrivate?
+    return "" if isPackage?
+    return " !! error : unknown visibility #{uri}!! "
+  end
+end
+
+module Muml_UML
+  #write java class modifiers if needed (abstract, public, ...)
+  #Example: public abstract
+  def java_writeClassModifiers
+    uml_visibility.each { |v|
+      write(v.java_visibilityModifiers)
+    }
+    write "abstract " if uml_isAbstract?
+  end
+
+  #write java static modifier if needed
+  def java_writeStaticModifier
+    write("static ") if uml_isStatic?
+  end
+
+end
+#module Muml_EnumerationLiteral
+#	def java_Name
+#	end
+#end
+module Muml_Enumeration
+
+  #writes java5 enum keyword and enum class name
+  #
+  #Example:
+  #* enum Colors
+  def java_writeMetaClassName
+    write("enum #{java_Name}")
+  end
+
+  #write enum body (list of litterals) using java_writeClassComment, java_writeClassModifiers, java_writeMetaClassName.
+  #
+  #Example:
+  #* { red,blue,green }
+  def java_writeClassBody
+    java_writeClassComment
+    java_writeJavadoc
+    java_writeAnnotation
+    java_writeMdatkAnno(['imports','javadoc','annotations']) if context[:hasGlobalReverse]
+    java_writeClassModifiers
+    java_writeMetaClassName
+    java_writeImplements
+    write("{\n")
+    sep=""
+    uml_ownedLiteral.sort { |a,b| a.java_Name.to_s <=> b.java_Name.to_s }.each { |c|
+      write(sep);
+      c.java_write
+      sep=",\n"
+    }
+    
+    if uml_ownedLiteral.empty?
+      label="null_literal"
+      write("/* TODO: #{label} literal  added by generator to work around a bug in hibernate which crash when an enum has no literal.*/\n#{label}\n")
+    end
+    
+    write(";\n") # literal/code separator
+
+    #java_writeDeclarationSpecificOnBegin
+    java_writeAttributes
+    write("\n\n")
+    #java_writeConstructors
+    write("\n\n")
+    java_writeOperations
+    java_writeCustomCode
+    #java_writeDeclarationSpecificOnEnd
+
+
+
+    write("\n}");
+  end
+
+  #write java implements declaration clause if needed.
+  #
+  #Example:
+  #* implements interface1, interface2
+  def java_writeImplements
+    imp=Set.new
+    uml_implementation.each { |g|
+      imp.add(g.uml_supplier_one.java_qualifiedName)
+    }
+    java_implements.each { |g|
+      imp.add(g)
+    }
+
+    sep="\nimplements "
+    imp.sort{ |a,b| a <=> b}.each { |g|
+      write(sep)
+      write(g)
+      sep=","
+    }
+  end
+
+end
+
+module Muml_Class
+
+  #Mark this java class as serializable.
+  #* adds implements java.io.Serializable
+  #* adds serialVersionUID variable
+  #Example:
+  #  private static final long serialVersionUID = 1L;
+  def java_makeSerializable!
+    #java_implements_add("java.io.Serializable");
+    s=umlx_getOrCreateClass("java.io.Serializable")
+    umlx_createAndAddImplementation(s)
+
+    p=umlx_createAndAddProperty(rdf_uri+"_serialVersionUID","serialVersionUID");
+    p.uml_visibility=::Cuml_VisibilityKind::Private
+    p.uml_isStatic=RDF_TRUE
+    p.java_isFinal=RDF_TRUE
+    p.java_isTransient=RDF_TRUE
+    p.uml_type=umlx_dataType_long
+    p.java_code="1L"
+    p.java_noAccessors=RDF_TRUE
+  end
+
+  #write java class keyword and class name
+  #
+  #Example:
+  #* classe Class1
+  def java_writeMetaClassName
+    if umlx_hasStereotype?('JavaAnnotation')
+      write(" @interface #{java_Name}")
+      return
+    end
+    write(" class #{java_Name}")
+  end
+
+  #write java implements declaration clause if needed.
+  #
+  #Example:
+  #* implements interface1, interface2
+  def java_writeImplements
+    imp=Set.new
+    uml_implementation.each { |g|
+      imp.add(g.uml_supplier_one.java_qualifiedName)
+    }
+    java_implements.each { |g|
+      imp.add(g)
+    }
+
+    sep="\nimplements "
+    imp.sort{ |a,b| a <=> b}.each { |g|
+      write(sep)
+      write(g)
+      sep=","
+    }
+  end
+
+  #Adds a constructor with paramter
+  #
+  #NOTE:
+  #* EXPERIMENTAL
+  #
+  #TODO: associations, et filtrer attributs static
+  def java_writeConstructors
+    write("  public #{java_Name}() {\n")
+    write("  }\n")
+    #TODO: associations ??, filtrer static
+    if (!uml_ownedAttribute.empty?)
+      parameters = ""
+      uml_ownedAttribute.each { |o|
+        if o.umlx_isAttribute?
+          parameters << ", "
+          parameters << o.java_propertyRoleType.to_s
+          parameters << " "
+          parameters << o.java_NameProperty
+        end
+      }
+      if (!parameters.empty?)
+        write("\n")
+        parameters = parameters.slice(1, parameters.length)
+        write("  public #{java_Name}(#{parameters}) {\n")
+        uml_ownedAttribute.each { |o|
+          if o.umlx_isAttribute?
+            write("    set#{o.java_NameBean}(#{o.java_NameProperty});\n")
+          end
+        }
+        write("  }\n")
+      end
+    end
+  end
+end
+
+
+module Muml_Classifier
+  include Mjava_Annotation
+  rdf_safe_attr_reader_many :java_import
+  rdf_safe_attr_reader_many :java_implements
+  rdf_safe_attr_reader_many :java_extends
+  rdf_safe_attr_reader_many :java_isATestFile
+
+  #true if this classifier is transient
+  rdf_safe_attr_reader_many :java_isTransient
+  rdf_safe_attr_reader_many :db_isTransient
+  rdf_safe_attr_reader_many :db_isDAO
+
+
+  #Returns the full java file name for this element
+  # (Uses: Java_FilePath and java_Name.)
+  #Example:
+  #* build/package1/package2/NomDeLaClasse.java
+  def java_FileName
+    return Pathname.new("#{java_FilePath}#{java_Name}.java").cleanpath.to_s
+  end
+
+  #Opens java_FileName for writing
+  #
+  #Example usage:
+  #java_openOutStream {
+  #	write ("this text goes in java file")
+  #	}
+  def java_openOutStream(&block)
+    mtk_writeSession(java_FileName) {
+      yield
+      #      if (context[:protectedReverse].protectedMode?)
+      #        write <<NOTICE
+      #\/\/**********************************************************************
+      #\/\/** This file is in REVERSE MODE. Text between tags will be saved
+      #\/\/** upon next generation if reverse="yes"
+      #\/\/** Element between tags are not stored in model, so this file should
+      #\/\/** manage in a version management tool.
+      #NOTICE
+      #        if context[:skipNoReverseMarker] 
+      #        write <<NOTICE2
+      #\/\/**
+      #\/\/** This file was generated with option --skipNoReverseMarker
+      #\/\/** Please set --no-skipNoReverseMarker if you wish to add a
+      #\/\/** reverse="yes" section.}  
+      #NOTICE2
+      #      end
+      #        
+      #      write <<NOTICE3
+      #\/\/**********************************************************************
+      #\/\/** Generated with ontoMDE (ORANGE-FT/RD/BIZZ/CIL/SAM 2006-2008)
+      #\/\/**********************************************************************
+      #NOTICE3
+      #
+      #
+      #    else
+      #      write <<NOTICE
+      #\/\/**********************************************************************
+      #\/\/** This file is in NOREVERSE MODE and was totaly generated from
+      #/\/\** model informations.
+      #/\/\** It is not mandatory to use a
+      #/\/\** version management tool for this file
+      #\/\/**********************************************************************
+      #\/\/** Generated with ontoMDE (ORANGE-FT/RD/BIZZ/CIL/SAM 2006-2007
+      #\/\/**********************************************************************
+      #NOTICE
+      #    end
+    }
+  end
+
+  #opens java file for writing with java_openOutStream and calls java_write
+  def java_generateClassifier
+    return if @java_already_generated
+    return if java_ignoreMe?
+
+    return unless self.umlx_owner_one.kind_of?(Muml_Package)
+    @java_already_generated=true
+
+    java_openOutStream {
+      mtk_context(:innerClass=> false,
+        :java_interface => kind_of?(Muml_Interface)) {
+        java_write
+      }
+    }
+  end
+
+  # write java code for class.
+  #  (Uses java_writeClassHeader, java_writeClassBody)
+  # NOTE
+  # * also used for inner classes
+  def java_write
+    java_writeClassHeader {
+      java_writeClassBody
+    }
+  end
+
+  # write java header.
+  #  (Uses java_writePackageDeclaration, java_writeImports)
+  #Exemple:
+  #   package pack1;
+  #   import xyz;
+  def java_writeClassHeader(&block)
+    if context[:innerClass]
+      yield
+      return
+    else
+      java_writePackageDeclaration {
+        java_writeImports
+        yield
+      }
+    end
+  end
+
+  # write java5 generic parameters
+  def  java_writeTemplateParameter
+    return if uml_ownedTemplateSignature.empty?
+    write("<")
+    sep=""
+    uml_ownedTemplateSignature.each {|ts|
+      #Muml_TemplateSignature
+      ts.uml_ownedParameter.each { |tp|
+        #Muml_TemplateParameter
+        write(sep)
+        sep=","
+        c=tp.uml_ownedParameteredElement_one
+        write(c.java_Name)
+        c.java_writeExtends(true)
+      }
+    }
+    write(">")
+  end
+
+  #java custom code overide to be
+  #inserted in custom code section
+  rdf_safe_attr_reader_many :java_customCode
+
+  # write class body.
+  #  (Uses java_writeClassComment, java_writeClassModifiers, java_writeMetaClassName, java_writeExtends, java_writeImplements, java_writeDeclarationSpecificOnBegin, java_writeAttributes, java_writeConstructors, java_writeOperations, java_writeDeclarationSpecificOnEnd)
+  def java_writeClassBody
+    java_writeClassComment
+    java_writeJavadoc
+    java_writeAnnotation
+    java_writeMdatkAnno(['imports','javadoc','annotations']) if context[:hasGlobalReverse]
+    java_writeClassModifiers
+    java_writeMetaClassName
+    java_writeTemplateParameter
+    java_writeExtends
+    java_writeImplements # class seulement
+    write("{\n")
+    
+    java_writeDeclarationSpecificOnBegin
+    java_writeAttributes
+    write("\n\n")
+    #java_writeConstructors
+    write("\n\n")
+    java_writeOperations
+    java_writeDeclarationSpecificOnEnd
+
+    mtk_context(:innerClass=>true) {
+      uml_nestedClassifier.each { |c|
+        next unless c.kind_of?(Muml_Class) 
+        #filter out Collaboration 
+        c.java_write
+      }
+    }
+    java_writeCustomCode
+    write("}\n")
+  end
+
+  #add add a custom code zone
+  #that is usefull for out of model code.
+  def java_writeCustomCode
+    mtk_protected(Mrdf_Resource::NOREVERSE,'custom_code') {
+      write !java_customCode.empty? ? java_customCode : <<END
+// Please use this area for out-of-model code.
+END
+    }
+    write("\n\n")
+  end
+  
+  #Does nothing.
+  def java_writeClassComment
+  end
+
+  #Does nothing.
+  def java_writeDeclarationSpecificOnBegin
+  end
+
+  #Does nothing.
+  def java_writeDeclarationSpecificOnEnd
+  end
+
+  #Does nothing.
+  def java_writeConstructors
+  end
+
+  #write java package declaration
+  # (Uses java_qualifiedName)
+  #
+  #Example:
+  #* package aPackage;
+  #* package aPackage.aPackage2;
+  #* //package --none--
+  def java_writePackageDeclaration(&block)
+    p = umlx_package
+    if p.nil? || p.umlx_isARootNamespace?
+      write("//package --none--;\n")
+    else
+      write("package #{p.java_qualifiedName};\n")
+    end
+    yield
+  end
+
+  #write java extends instructions is necessary
+  # (Uses java_qualifiedName)
+  #
+  #Example:
+  #   extends Class2,Class3
+  def java_writeExtends(isTemplateParameter=false)
+    ext=Set.new
+    nbrInterface=0;
+
+    uml_generalization.each { |g|
+      nbrInterface+=1
+      if (nbrInterface>1) && !kind_of?(Muml_Interface)
+        write("\n/*TODO: UML model defines multiple inheritance (#{g.uml_general_one.java_qualifiedName})*/")
+      else
+        ext.add(g.uml_general_one.java_qualifiedName)
+      end
+    }
+    java_extends.each { |g|
+      nbrInterface+=1
+      if nbrInterface>1
+        write("\n/*TODO: UML model defines multiple inheritance (#{g})*/")
+      else
+        ext.add(g)
+      end
+    }
+    sep=isTemplateParameter ? " extends " : "\nextends "
+    ext.sort{ |a,b| a <=> b}.each { |g|
+      write(sep)
+      write(g)
+      sep=","
+    }
+
+  end
+
+  # if true, generator will compute depencies and add imports
+  # NOTE !!
+  #   This feature was added for derived generators.
+  #   It's use is **not** recommended  for **java**.
+  #   Problems will occur if model manipulate classes
+  #   such as java.sql.Date and java.lang.Date simultaneously.
+  JAVA_IMPORT_COMPUTED_DEPENDENCIES=false
+
+  #write import instructions
+  #
+  #NOTE:
+  #  The generator always uses qualified names, thus imports are not used by the generator.
+  #  Using short names leads to name clash. (different Date class, ...)
+  #
+  #  Letting eclipse handle imports is a the best solution.
+  #
+  #  Eclipse offers a highly convenient organize imports feature.
+  #  Developer should generate java code squeleton and fill it with their code eventually
+  #  using ECLIPSE organize import features.
+  def java_writeImports
+    setOfImport=Set.new
+    java_import.each { |imp|
+      setOfImport<< imp
+    }
+    JAVA_DEFAULT_IMPORTS.each { |c|
+      setOfImport<< c
+    }
+    if(JAVA_IMPORT_COMPUTED_DEPENDENCIES)
+      umlx_computeDirectDepencies().each { |c|
+        m=c.java_qualifiedName
+        #Concrete type may come from a datatype mapping definition and be either a class or a language datatype.
+        next unless m.index(".")
+        setOfImport<< m
+      }
+    end
+
+    if (setOfImport.empty?) && !context[:hasGlobalReverse]
+      # adds a useless import so eclipse
+      # will place imports in the right area (between ontomde reverse marquers)
+      # when using "organize import" eclipse feature.
+      if umlx_owner_one.umlx_isARootNamespace?
+        #import of class in root package is invalid
+        setOfImport<<"java.lang.Object"
+      else
+        #we import something
+        setOfImport<< self.java_qualifiedName;
+      end
+    end
+
+    mtk_protected(Mrdf_Resource::NOREVERSE,'imports',context[:hasGlobalReverse]) {
+      setOfImport.sort { |a,b| a <=> b}.each {|imp|
+        write("import #{imp};\n");
+      }
+      if context[:hasGlobalReverse]
+        write("import xmda.annotationOntoMDE.OntoMDE;\nimport static xmda.annotationOntoMDE.OntoMDE.ZoneCode.*;\n")
+      end
+    }
+  end
+
+  #default java imports
+  JAVA_DEFAULT_IMPORTS=[  ];
+
+  #iterate java_write on operations
+  def java_writeOperations
+    #sort has been added because ownedOperation order is random
+    #which is cause false change detection on versionned file
+    uml_ownedOperation.sort { |a,b| a.java_Name.to_s <=> b.java_Name.to_s }.each { |o| o.java_write}
+  end
+
+  #iterate java_write on attributes
+  #
+  #NOTE
+  #* no attribute is generated for an interface
+  #* getter/setter// are not handled here (see java_transform!).
+  def java_writeAttributes
+    return if kind_of?(Muml_Interface)
+    #sort has been added because ownedAttribute order is random
+    #which is cause false change detection on versionned file
+    uml_ownedAttribute.sort { |a,b| a.java_Name.to_s <=> b.java_Name.to_s }.each { |o| o.java_write}
+  end
+end
+
+module Muml_Stereotype_Create
+  def java_write
+    write("\n")
+    java_writeAnnotation
+    java_writeMethodModifiers
+
+    #write("#{uml_class_one.java_Name}")
+    write("#{uml_ownedOperation_inv_one.java_Name}")
+
+    java_writeMethodParameters
+    java_writeMethodThrows
+    java_writeMethodBody
+  end
+end
+
+module Muml_Operation
+  rdf_safe_attr_reader_many :java_getter_property
+  rdf_safe_attr_reader_many :java_setter_property
+  include Mjava_Annotation
+
+  #Attribut pouvant contenir le code java de la methode.
+  #Utilise lorsque le java_code est calcul? automatiquement.
+  rdf_safe_attr_reader_many :java_code
+
+  #is operation synchronised
+  rdf_safe_attr_reader_many :java_isSynchronised
+
+  #write java operation skeleton.
+  # (Uses java_writeMethodModifiers, java_writeMethodReturnType, java_writeMethodParameters, java_writeMethodThrows, java_writeMethodBody)
+  def java_write
+    write("\n")
+    java_writeJavadoc
+    java_writeAnnotation
+    java_writeMdatkAnno(!(uml_isAbstract? || context[:java_interface])?['javadoc','annotations','annoparam0','0']:['javadoc','annotations','annoparam0']) if context[:hasGlobalReverse]
+    java_writeMethodModifiers
+
+    if(umlx_isConstructor?)
+      write("#{umlx_class_one.java_Name}")
+    else
+      java_writeMethodReturnType
+      write("#{java_Name}")
+    end
+    java_writeMethodParameters
+    java_writeMethodThrows
+    java_writeMethodBody
+  end
+
+  #write java method modifiers.
+  # (Uses java_writeAbstract, java_visibilityModifiers, java_writeStaticModifiers)
+  # Visibility is not generated for interfaces (to make checkstyle happy)
+  #Example:
+  #* abstract public
+  #* public static
+  def java_writeMethodModifiers
+
+
+    if !umlx_class_one.kind_of?(Muml_Interface)
+      uml_visibility.each { |v|
+        write(v.java_visibilityModifiers)
+      }
+    end
+    java_writeStaticModifier
+    java_writeAbstract
+    write "synchronized "if java_isSynchronised?
+
+    #java_writeModifiers
+    #abstract synchronized ...
+    #TODO uml_classifier_isAbstract
+  end
+
+  #write abstract keyword if necessary.
+  def java_writeAbstract
+    write("abstract ") if uml_isAbstract?
+  end
+
+  #write method return type
+  # (Uses java_writeParameterType)
+  def java_writeMethodReturnType
+    java_writeParameterType(umlx_returnResult_one0)
+  end
+
+  #write java type parameter (without the name)
+  #
+  #Example:
+  #* void
+  #* int
+  #* pack1.Class1
+  def java_writeParameterType(fp)
+    if (fp.nil?)
+      write("void ")
+    else
+      fp.java_write
+      #uml_isException (!! a ne pas confondre avec une exception)
+      #uml_isOrdered
+      #uml_isStream
+      #uml_isUnique
+    end
+  end
+  #Write the body of a java method.
+  #
+  #NOTE:
+  #* The default generated operation throws a RuntimeException
+  #* mtk_protected is used to allow inline java code modification (with Eclipse)
+  def java_writeMethodBody
+    if uml_isAbstract? || context[:java_interface]
+      write(";\n")
+    else
+      write("{\n");
+      mtk_protected(Mrdf_Resource::NOREVERSE,'0',context[:hasGlobalReverse]) {
+        if ! java_code_one0.nil?
+          write java_code
+        else
+          java_writeMethodBodyNotImplemented
+        end
+        write("\n")
+      }
+      write("}\n");
+    end
+  end
+
+  #writes default code for a method not implemented
+  def java_writeMethodBodyNotImplemented
+    write <<END
+  //TODO: implement method body
+  throw new java.lang.RuntimeException("[operation \\"#{java_Name}\\"not implemented]");
+END
+  end
+
+  # write method throw clause.
+  #  (Uses java_qualifiedName )
+  #
+  # Example:
+  # * throws java.lang.Exception
+  def java_writeMethodThrows
+    sep=" throws "
+
+    uml_raisedException.each { |exception|
+      write(sep);
+      write(exception.java_qualifiedName)
+      sep=","
+    }
+  end
+
+  #write method parameters
+  #
+  #Example:
+  #* ()
+  #* (int x)
+  #* (pack1.Class1 xyz, String z)
+  def java_writeMethodParameters
+    write("(")
+    sep=""
+    i = 0
+    uml_ownedParameter.each { |op|
+      next if op.uml_direction_one.isReturn?
+      write(sep)
+      sep=","
+      op.java_writeParamAnnotation i.to_s
+      op.java_write
+      i = i + 1
+    }
+    write(")")
+  end
+end
+
+module Muml_Property
+  include Mjava_Annotation
+  rdf_safe_attr_reader_many :java_AttributeGlobalSetter
+  rdf_safe_attr_reader_many :java_AttributeGlobalGetter
+
+  #Attribut pouvant contenir la valeur initiale.
+  #Utilise lorsque le java_code est calcul? automatiquement.
+  rdf_safe_attr_reader_many :java_code
+
+  #Transient attribute
+  rdf_safe_attr_reader_many :java_isTransient
+
+  #is persistent (in database)
+  rdf_safe_attr_reader_many :db_isTransient
+
+  #property is final
+  rdf_safe_attr_reader_many :java_isFinal
+
+  #Methode vide
+  def java_writePropertyComment
+  end
+  #Methode vide
+  def java_writeGetterComment
+  end
+  #Methode vide
+  def java_writeSetterComment
+  end
+
+  #write java attribute variable
+  # (Uses java_writePropertyComment, java_writePropertyModifiers ,java_propertyRoleType,java_NameProperty)
+  #
+  #NOTE:
+  #* getter/setter/... methods are handled by model transformation
+  def java_write
+    if !uml_isDerived?
+      java_writePropertyComment
+      java_writeJavadoc
+      java_writeAnnotation
+      java_writeMdatkAnno(['javadoc','annotations']) if context[:hasGlobalReverse]
+      write("  ");
+      java_writePropertyModifiers
+      write("#{java_propertyAssociationType}")
+      write(" #{java_NameProperty}")
+
+      if !java_code.empty?
+        write"= #{java_code}"
+      elsif(context[:java_generateSetAttributeInitializer])
+        if (!umlx_upperValueIsOne?) && uml_qualifier.empty? && java_use_Arrays?
+          write("= new ");
+          write(uml_type_one.java_qualifiedName)
+          write("[1]")
+        elsif (!umlx_upperValueIsOne?) && uml_qualifier.empty?
+          write("= new ");
+          write(java_propertyAssociationConcreteType)
+          write("()")
+        elsif umlx_upperValueIsOne? && !uml_qualifier.empty?
+          write("= new ");
+          write(java_propertyAssociationConcreteType)
+          write("()")
+        elsif !umlx_upperValueIsOne? && !uml_qualifier.empty?
+          #write("= new ");
+          #write(java_propertyAssociationConcreteType)
+          #write("()")
+        end
+      end
+      write(";\n")
+    end
+  end
+
+
+
+  #write java modifiers if needed (public, static, ...)
+  # (Uses java_visibilityModifiers, java_writeStaticModifier)
+  # example: private static    final   transient long
+  def java_writePropertyModifiers
+
+    uml_visibility.each { |v|
+      write(v.java_visibilityModifiers)
+    }
+    java_writeStaticModifier
+    java_writeFinalModifier
+    java_writeTransient
+  end
+
+  def java_writeFinalModifier
+    return unless java_isFinal?
+    write "final "
+  end
+
+  #write java transient modifier if needed.
+  def java_writeTransient
+    return unless java_isTransient?
+    write("transient ")
+  end
+
+end
+
+
+
+module Muml_TypedElement
+  rdf_safe_attr_reader_many :java_use_Arrays
+
+  #return java property type.
+  # (Uses java_qualifiedName)
+  #
+  #NOTE
+  #* used for UML Parameter and UML Property
+  #* return "int" and a TODO comment if uml_type is undefined.
+  #
+  #Example:
+  #* String
+  #* Set<String>
+  def java_propertyRoleConcreteType
+    return java_getCollectionMapping.addCollectionImplem(
+      uml_type.empty? ? "Integer /* TODO: FIX:undefined type in uml model */ " : uml_type_one.java_qualifiedName )
+  end
+
+  def java_propertyRoleType
+    return java_getCollectionMapping.addCollectionInterface(
+      uml_type.empty? ? "Integer /* TODO: FIX:undefined type in uml model */ " : uml_type_one.java_qualifiedName )
+  end
+
+  def java_propertyAssociationConcreteType
+    return java_propertyRoleConcreteType if uml_qualifier.empty?
+    j="java.util.Hashtable<"
+    sep_next=""
+    uml_qualifier.each { |key|
+      j=j+sep_next+key.java_propertyRoleConcreteType
+      sep_next=","
+    }
+    j=j+","+java_propertyRoleConcreteType+">"
+    return j
+  end
+  def java_propertyAssociationType
+    return java_propertyRoleType if uml_qualifier.empty?
+    j="java.util.Hashtable<"
+    sep_next=""
+    uml_qualifier.each { |key|
+      j=j+sep_next+key.java_propertyRoleType
+      sep_next=","
+    }
+    j=j+","+java_propertyRoleType+">"
+    return j
+  end
+end
+
+
+
+module Muml_DataType
+  #Predefined UML datatype to Java type mapping.
+  #Note: A string is used for Calendar.
+  #UML_TO_JAVA_PRIMITIVE_TYPE_MAPPING={"byte"=>"byte","short"=>"short","long"=>"long","Boolean"=>"boolean","boolean"=>"boolean","int"=>"int","integer"=>"int","Integer"=>"int", "String"=>"String","string"=>"String","date"=>"java.util.Date","double"=>"double","char"=>"char","Calendar"=>"String","TimeStamp"=>"java.util.Date"}
+
+  # returns datatype qualified name.
+  #
+  # NOTE:
+  # * A predefined mapping is defined UML_TO_JAVA_PRIMTIVE_TYPE_MAPPING
+  # * MagicDraw handles primtive types as DataType
+  # * RSM       handles primtive types as PrimitiveType
+  def java_qualifiedName
+    return super if kind_of?(Muml_Enumeration)
+
+    return DatatypeMapping.instance.getMapping(self).java_getType
+
+
+    ot=uml_name_one
+    mt=::Muml_PrimitiveType::UML_TO_JAVA_PRIMITIVE_TYPE_MAPPING[ot]
+    return mt unless mt.nil? || mt.to_s==""
+    #avoid multiple messages
+    ::Muml_PrimitiveType::UML_TO_JAVA_PRIMITIVE_TYPE_MAPPING[ot]="String"
+    log.error %{
+WARN: A default java mapping has been created for DataType #{ot}
+HELP:
+HELP: To declare a new mapping, create a new entry as shown bellow:
+HELP: module Muml_DataType
+HELP:  UML_TO_JAVA_PRIMITIVE_TYPE_MAPPING["#{ot}"]="your target java type"
+HELP: end
+    } #(not useful here) unless log_already_displayed?("#{rdf_uri}__datatype")
+    return java_qualifiedName # retry
+  end
+end
+
+module Mrdf_Resource
+  #return true if java generator should totaly ignore this element.
+  #
+  #NOTE:
+  #* Default implementation returns false
+  def java_ignoreMe?
+    return false
+  end
+end
+
+#module Muml_ClassifierTemplateParameter
+#	def umlx_hierarchy
+#		return nil
+#	end
+#	def java_ignoreMe?
+#		return true
+#	end
+#end
+
+
+
+
+module Muml_Interface
+
+  #does nothing
+  def java_writeImplements
+  end
+
+  #write java interface keyword and interface name
+  #
+  #Example:
+  #* interface Interface1
+  def java_writeMetaClassName
+    write("interface #{java_Name}")
+  end
+
+  def java_makeSerializable!
+    #java_implements_add("java.io.Serializable");
+    s=umlx_getOrCreateClass("java.io.Serializable")
+    umlx_createAndAddGeneralization(s)
+  end
+end
+