ontomde-java 2.0.0

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

@@ -0,0 +1,65 @@
+# Handle multi-tenant applications
+ 
+module Mrdf_Repository
+  
+  # default qualified name of the class used for tenant
+  TENANT_DEFAULT_CLASS_QUALIFIED_NAME='xmda.tenant.Tenant'
+  
+  # stereotype name used to identify a tenant in model
+  TENANT_STEREOTYPE_NAME='tenant'
+  
+  def java_getTenantClass
+    tenant=nil
+    uml_Class_all.each { |c|
+      next unless c.umlx_hasStereotype?(TENANT_STEREOTYPE_NAME)
+      unless tenant.nil?
+        puts 'ERROR: ****************************************************'
+        puts 'ERROR: multiple class found in model with stereotype tenant'
+        puts 'ERROR: ****************************************************'
+      end
+      tenant=c
+    }
+    return tenant
+  end
+  def java_addTenantClass!   
+    # look in model for an existing class stereotyped "tenant"
+    tenant=java_getTenantClass
+    
+    # fields should be provided by model
+    return tenant unless tenant.nil?
+    
+    # no tenant class found in model. we will create one.
+    tenant=umlx_reserved_model.umlx_getOrCreateClass(TENANT_DEFAULT_CLASS_QUALIFIED_NAME)
+    f=tenant.umlx_createAndAddProperty(tenant.rdf_uri+"_tname","tenant Name")
+    f.uml_type=tenant.umlx_owner_one.umlx_dataType_string
+    tenant.umlx_external=RDF_FALSE
+    tenant.db_isTransient=RDF_FALSE
+    
+    tenant.uml_appliedStereotype_add(tenant.umlx_getOrCreateStereotype(TENANT_STEREOTYPE_NAME))
+    return tenant
+  end
+  
+  def java_addTenantFields!
+    tenant=java_addTenantClass!
+    uml_Class_all.each { |c|
+      next if c.kind_of?(Muml_Interface)
+      next unless c.uml_generalization.empty?
+      c.java_addTenantField!(tenant)
+    }
+  end
+end
+
+module Muml_Classifier
+  TENANT_FIELD_NAME="tenantOwner"
+  def java_addTenantField!(tenantClass=nil)
+    return unless context[:multiTenant]
+    tenantClass=rdf_Repository.java_getTenantClass if tenantClass.nil?
+   # return if tenantClass==self
+   #Tenant itself has a tenant field for homogenity
+   #
+    tf=umlx_createAndAddProperty("#{self.rdf_uri}_tenant",TENANT_FIELD_NAME)
+    tf.uml_type=tenantClass
+  end
+end
+
+

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

@@ -0,0 +1,1363 @@
+#:include: java.rdoc
+#:include: xsd_todo.rdoc
+
+require 'pathname'
+
+module Mxsd_Schema
+  #model elements in file 
+  rdf_attr :xsd_types,[::Muml_Element ]
+
+  #model element which will be used to compute file name
+  rdf_attr :xsd_baseName, [ ::Muml_Namespace ]
+
+  #included xsd files
+  rdf_attr :xsd_dependencies, [ ::Mxsd_Schema ]
+	
+  #return set of types used by attributes of classes in current xsd file.
+  def xsd_getSetOfTypeUsedByAttributes
+    types=Set.new
+    xsd_types.each { |clazz|
+      clazz.uml_ownedAttribute.each { |param|
+        types.merge(param.uml_type)
+      }
+    }
+    return types
+  end
+
+  def xsd_writeImports
+    xsd_dependencies.each {|dep|
+      base=Pathname.new(File.dirname(self.xsd_SchemaName))
+      target=Pathname.new(dep.xsd_SchemaName)
+      write(%{  <xsd:include schemaLocation="#{target.relative_path_from(base)}"/>\n})
+    }
+  end
+  #compute xsd dependencies from file
+  def xsd_computeDependencies!(defaultXSD)
+    deps=Set.new 
+    xsd_getSetOfTypeUsedByAttributes.each { |clazz|
+      clazz.xsd_types_inv.each {|i|
+        next if i==self
+        deps.add(i)	  
+      }
+    }
+    deps.each {|d|
+      xsd_dependencies_add(d)
+    }
+    return 
+  end
+  
+  
+  XSD_HEADER=<<END
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+END
+  XSD_FOOTER=<<END
+</xsd:schema>
+END
+  
+  def xsd_generateSchema
+    xsd_openOutStream {
+      write(XSD_HEADER)
+      xsd_writeImports
+      xsd_types.each { |clazz|
+        #        puts "--> #{clazz}"
+        clazz.xsd_writeType
+      }
+      write(XSD_FOOTER)
+    }
+  end
+  
+  def xsd_SchemaName
+    if xsd_baseName.empty?
+      return "global.xsd"
+    else
+      return xsd_baseName_one.xsd_SchemaName
+    end
+  end
+  
+  #Opens xsd_SchemaName for writing
+  #
+  #Example usage:
+  #xsd_openOutStream {
+  #	write ("this text goes in java file")
+  #	}
+  def xsd_openOutStream(&block)
+    mtk_writeSession(xsd_SchemaName) {
+      yield
+    }
+  end
+
+  #  #opens java file for writing with xsd_openOutStream and calls xsd_write
+  #  def xsd_generate
+  #    return if @xsd_already_generated
+  #    return if xsd_ignoreMe?
+  #
+  #    return unless self.umlx_owner_one.kind_of?(Muml_Package)
+  #    @xsd_already_generated=true
+  #
+  #    xsd_openOutStream {
+  #        xsd_write
+  #    }
+  #  end
+
+  #  # write java code for class.
+  #  #  (Uses xsd_writeClassHeader, xsd_writeClassBody)
+  #  # NOTE
+  #  # * also used for inner classes
+  #  def xsd_write
+  #    puts "&&"
+  #    xsd_writeClassHeader {
+  #      xsd_writeClassBody
+  #      xsd_types.each { |clazz|
+  #        puts "--> #{clazz}"
+  #        clazz.xsd_write
+  #      }
+  #    }
+  #  end
+
+end
+
+class Cxsd_Schema <  Crdf_Resource
+  include Mxsd_Schema
+end
+
+module Mrdf_Repository
+  
+  # Example
+  # xsd_addJavaFilePathMapping(/\.example/,"src/main/example/" ])
+  #TODO: add helping error if jfp.nil?
+  def xsd_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 xsd_transform! for every class element
+  def xsd_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.xsd_transform! unless c.xsd_ignoreMe?
+    }
+
+    #xsd_addPersistence!
+    umlx_processStereotypes!
+  end
+
+  #Main java generator entry point.
+  #Triggers the generation of every Java file for the model.
+  def xsd_generate_all
+    each_value {|m|
+      next unless m.kind_of?(Mxsd_Schema)
+      #      puts "!!"
+      m.xsd_generateSchema
+    }
+  end
+  
+  #parse model and generate file objects for elements 
+  def xsd_generateSchemaElements!
+    packages=Set.new
+    uml_Class_all.each { |c|
+      packages.add(c.umlx_owner_one)
+    }
+    global=Cxsd_Schema.new(self,"uri://globalXSD")
+    xsdFiles=Set.new
+    packages.each { |p|
+      f=Cxsd_Schema.new(self,"#{p.rdf_uri}_xsdFile")
+      xsdFiles.add(f)
+      f.xsd_baseName=p
+      p.uml_Class_all.each {|oe|
+        f.xsd_types_add(oe)
+      }
+    }
+    d=global.nil? ? Cxsd_Schema.new(self,"defaultXSD") : global
+    xsdFiles.each {  |xsd|
+      xsd.xsd_computeDependencies!(d)
+    }
+  end
+        
+  def xsd_generateXSDFiles
+    each_value { |v|
+      next unless v.kind_of?(Mxsd_Schema)
+      v.generateXSDFile
+    }
+  end
+        
+end
+
+module Mxsd_Annotation
+  rdf_safe_attr_reader_many :xsd_annotation
+  def xsd_writeAnnotation
+    mtk_protected(Mrdf_Resource::NOREVERSE,"annotations") {
+      xsd_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
+end
+
+
+
+
+
+module Muml_EnumerationLiteral
+  #List of initialisation parameter for this literal.
+  rdf_safe_attr_reader_many :xsd_initParameterValue
+end
+
+module Muml_Parameter
+  # extension metamodele
+  rdf_safe_attr_reader_many :uml_qualifier
+  #rdf_safe_attr_reader_many :umlx_qualifier
+
+  #write java parameter declaration
+  # (Uses xsd_propertyRoleType, xsd_Name)
+  # parameter is declared final if direction is in (not out, not inOut)
+  #Example:
+  #* int x
+  #* final int x
+  #* String z
+  def xsd_write
+    write("final ") if uml_direction_one.isIn? # the best we can do with java
+    write("#{xsd_propertyAssociationType} ")
+    #write(" /* #{uml_lowerValue}..#{uml_upperValue}*/ ")
+    write(" #{xsd_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 xsd_ignoreMe?
+    return true;
+  end
+end
+
+
+
+
+module Muml_Model
+  #def xsd_generate_all
+  ##  mtk_default_context(:xsd_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.xsd_isATestFile? && !context[:includeTestFiles]
+  ##      next if (!c.xsd_isATestFile?) && context[:excludeNonTestFiles]
+  ##      c.xsd_generate
+  ##    }
+  ##    if context[:generateComponent]
+  ##      uml_Component_all.each  { |c|
+  ##        c.xsd_generateType
+  ##      }
+  ##    end
+  ##  }
+  #end
+end
+
+#module Muml_Property
+#	def xsd_Name
+#		return uml_isStatic? ? super.upcase : super
+#	end
+#end
+
+module Muml_NamedElement
+  # true if name contains a generic.
+  rdf_safe_attr_reader_many :xsd_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:
+  # xsd_safeName("number") returns number
+  # xsd_safeName("8number")  returns _number
+  def xsd_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 xsd_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 xsd_uniqueName
+    ret=xsd_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[:xsd_failIfNonUniqueName]
+      raise Warning.new(),"unique name assertion failed"
+    end
+
+  end
+
+  #Returns this element uml_name after applying xsd_safeName on it.
+  @xsd_Name_cache=nil
+  def xsd_Name
+    return @xsd_Name_cache unless @xsd_Name_cache.nil?
+    s=xsd_safeName(uml_name.to_s)
+    b=context[:xsd_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_xsd_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_xsd_Name_case_error(false)
+      end
+    end
+    @xsd_Name_cache=s
+    return @xsd_Name_cache
+  end
+  #DISPLAY_JAVA_NAME_CASE_ERROR=Set.new()
+  def display_xsd_Name_case_error(isDowncase)
+    return unless context[:xsd_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 xsd_Name after applying a simplified java bean case convention.
+  #http://java.sun.com/products/javabeans/docs/spec.html
+  #anIntAttribute --> AnIntAttribute
+  #aBooleanAttribute --> aBooleanAttribute
+  def xsd_NameBean
+    return xsd_toNameBean(xsd_Name.to_s)
+  end
+  def xsd_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 xsd_Name after applying a simplified java bean property case convention.
+  def xsd_NameProperty
+    return xsd_Name
+    #return xsd_toNameProperty(xsd_Name)
+  end
+
+  #Converts string name to a property name and returns its value.
+  #
+  #Example:
+  #   xsd_toNameProperty("Xyz") return "xyz"
+  #   xsd_toNameProperty("XYZ") return "xYZ"
+  def xsd_toNameProperty(name)
+    result = String.new(name)
+    if !result.empty?
+      result[0] = result[0, 1].downcase
+    end
+    return result
+  end
+end
+
+module Muml_Namespace
+  #Returns the full java file name for this element
+  # (Uses: Java_FilePath and xsd_Name.)
+  #Example:
+  #* build/package1/package2/NomDeLaClasse.xsd
+  def xsd_SchemaName
+    return "#{xsd_SchemaPath}#{xsd_Name}.xsd"
+  end
+
+
+  def xsd_getContextJavaFilePath(default=nil)
+    n=xsd_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.xsd
+  def xsd_SchemaPath
+    return xsd_getContextJavaFilePath(context[:javaDir])+xsd_InternalFilePath
+  end
+
+  # Returns the internal path where to generate file for this object.
+  #
+  # NOTE:
+  #
+  # Examples
+  # *package1/package2
+  # *package1/package2/UneClasse.xsd
+  def xsd_InternalFilePath
+    r=""
+    umlx_sub_hierarchy.each { |n|
+      r+=n.xsd_Name
+      r+="/"
+    }
+    return r
+  end
+
+  #Returns this element java qualified name
+  #
+  #Example:
+  #  package1.package2.AClassClasse
+  #  AClassInRootDefaultPackage
+  #  package1.package2
+  def xsd_qualifiedName
+    r=sep=""
+    umlx_hierarchy.each { |n|
+      r+=sep
+      r+=n.xsd_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 xsd_ignoreMe?(ignoreExternal=true)
+    #puts "ignore=#{self.class} #{self.uml_name}"
+    qn=xsd_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 xsd_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 xsd_writeClassModifiers
+    #uml_visibility.each { |v|
+    #  write(v.xsd_visibilityModifiers)
+    #}
+    write "abstract " if uml_isAbstract?
+  end
+
+  #write java static modifier if needed
+  def xsd_writeStaticModifier
+    write("static ") if uml_isStatic?
+  end
+
+end
+#module Muml_EnumerationLiteral
+#	def xsd_Name
+#	end
+#end
+module Muml_Enumeration
+
+  #writes java5 enum keyword and enum class name
+  #
+  #Example:
+  #* enum Colors
+  def xsd_writeMetaClassName(&block)
+    write(%{<xsd:simpleType name="#{xsd_qualifiedName}" >\n})
+    yield
+    write(%{</xsd:simpleType>\n})
+  end
+
+  #write enum body (list of litterals) using xsd_writeClassComment, xsd_writeClassModifiers, xsd_writeMetaClassName.
+  #
+  #Example:
+  #* { red,blue,green }
+  def xsd_writeType
+    xsd_writeMetaClassName {
+      xsd_writeExtends {
+        xsd_writeClassComment
+        #xsd_writeJavadoc
+        #xsd_writeAnnotation
+        xsd_writeClassModifiers
+      
+        write(%{     <xsd:restriction base="xsd:string">\n})
+        uml_ownedLiteral.each {|c|
+          write(%{       <xsd:enumeration value="#{c.xsd_Name}"/>\n})
+        }
+        write(%{     </xsd:restriction>\n})
+    
+        #xsd_writeDeclarationSpecificOnBegin
+        #skip: xsd_writeAttributes
+        #xsd_writeConstructors
+        #xsd_writeOperations
+        xsd_writeCustomCode
+        #xsd_writeDeclarationSpecificOnEnd
+      }
+    }
+  end
+
+  #write java implements declaration clause if needed.
+  #
+  #Example:
+  #* implements interface1, interface2
+  def xsd_writeImplements
+    imp=Set.new
+    uml_implementation.each { |g|
+      imp.add(g.uml_supplier_one.xsd_qualifiedName)
+    }
+    xsd_implements.each { |g|
+      imp.add(g)
+    }
+
+    sep="\n<!-- implements "
+    e=""
+    imp.sort{ |a,b| a <=> b}.each { |g|
+      write(sep)
+      write(g)
+      sep=","
+      e=" -->"
+    }
+    write(e)
+  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 xsd_makeSerializable!
+    #xsd_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.xsd_isFinal=RDF_TRUE
+    p.xsd_isTransient=RDF_TRUE
+    p.uml_type=umlx_dataType_long
+    p.xsd_code="1L"
+    p.xsd_noAccessors=RDF_TRUE
+  end
+
+
+
+  #write java implements declaration clause if needed.
+  #
+  #Example:
+  #* implements interface1, interface2
+  def xsd_writeImplements
+    imp=Set.new
+    uml_implementation.each { |g|
+      imp.add(g.uml_supplier_one.xsd_qualifiedName)
+    }
+    xsd_implements.each { |g|
+      imp.add(g)
+    }
+
+    #    sep=""# \n<!-- implements "
+    #    e=""
+    #    imp.sort{ |a,b| a <=> b}.each { |g|
+    #      write(sep)
+    #      write(g)
+    #      sep=","
+    #      e=" -->"
+    #    }
+    #    write(e)
+  end
+
+  #Adds a constructor with paramter
+  #
+  #NOTE:
+  #* EXPERIMENTAL
+  #
+  #TODO: associations, et filtrer attributs static
+  def xsd_writeConstructors
+    write("  public #{xsd_Name}() {\n")
+    write("  }\n")
+    #TODO: associations ??, filtrer static
+    if (!uml_ownedAttribute.empty?)
+      parameters = ""
+      uml_ownedAttribute.each { |o|
+        if o.umlx_isAttribute?
+          parameters << ", "
+          parameters << o.xsd_propertyRoleType.to_s
+          parameters << " "
+          parameters << o.xsd_NameProperty
+        end
+      }
+      if (!parameters.empty?)
+        write("\n")
+        parameters = parameters.slice(1, parameters.length)
+        write("  public #{xsd_Name}(#{parameters}) {\n")
+        uml_ownedAttribute.each { |o|
+          if o.umlx_isAttribute?
+            write("    set#{o.xsd_NameBean}(#{o.xsd_NameProperty});\n")
+          end
+        }
+        write("  }\n")
+      end
+    end
+  end
+end
+
+
+module Muml_Classifier
+  include Mxsd_Annotation
+  rdf_safe_attr_reader_many :xsd_import
+  rdf_safe_attr_reader_many :xsd_implements
+  rdf_safe_attr_reader_many :xsd_extends
+  rdf_safe_attr_reader_many :xsd_isATestFile
+
+  #true if this classifier is transient
+  rdf_safe_attr_reader_many :xsd_isTransient
+  rdf_safe_attr_reader_many :db_isTransient
+  rdf_safe_attr_reader_many :db_isDAO
+
+
+
+
+  #write java class keyword and class name
+  #
+  #Example:
+  #* classe Class1
+  def xsd_writeMetaClassName(&block)
+    write(%{  <xsd:complexType name="#{xsd_qualifiedName}">\n})
+    yield
+    write(%{  </xsd:complexType>\n})
+  end
+
+
+  # write java header.
+  #  (Uses xsd_writePackageDeclaration, xsd_writeImports)
+  #Exemple:
+  #   package pack1;
+  #   import xyz;
+  def xsd_writeClassHeader(&block)
+    return if context[:innerClass]
+    #xsd_writePackageDeclaration {
+    write(XSD_HEADER)
+    xsd_writeImports
+    yield
+    write(XSD_FOOTER)
+    #}
+  end
+
+  #java custom code overide to be
+  #inserted in custom code section
+  rdf_safe_attr_reader_many :xsd_customCode
+
+  # write class body.
+  #  (Uses xsd_writeClassComment, xsd_writeClassModifiers, xsd_writeMetaClassName, xsd_writeExtends, xsd_writeImplements, xsd_writeDeclarationSpecificOnBegin, xsd_writeAttributes, xsd_writeConstructors, xsd_writeOperations, xsd_writeDeclarationSpecificOnEnd)
+  def xsd_writeType
+    xsd_writeMetaClassName {
+      xsd_writeExtends {
+        # #     xsd_writeClassComment
+        #      xsd_writeJavadoc
+        #      xsd_writeAnnotation
+        #      xsd_writeClassModifiers
+        #      xsd_writeExtends
+        #      xsd_writeImplements # class seulement
+        #      # write("{\n")
+        #      xsd_writeCustomCode
+        #    
+        #      xsd_writeDeclarationSpecificOnBegin
+        xsd_writeAttributes
+        #write("\n\n")
+        #xsd_writeConstructors
+#        write("\n\n")
+        #xsd_writeOperations
+        xsd_writeDeclarationSpecificOnEnd
+
+        mtk_context(:innerClass=>true) {
+          uml_nestedClassifier.each { |c|
+            puts "ignored nested classifier #{c} in #{self}"
+            #c.xsd_writeType # !!
+          }
+        }
+      }
+    }
+  end
+
+  #add add a custom code zone
+  #that is usefull for out of model code.
+  def xsd_writeCustomCode
+    mtk_protected(Mrdf_Resource::NOREVERSE,"custom_code") {
+      write !xsd_customCode.empty? ? xsd_customCode : <<END
+<!-- ***********************************************
+     This area is provided to insert special code
+     that cannot be handled by generator.
+     Please, don't use custom method to avoid
+     keeping source models up to date. 
+     *********************************************** -->
+END
+    }
+  end
+  
+  #Does nothing.
+  def xsd_writeClassComment
+  end
+
+  #Does nothing.
+  def xsd_writeDeclarationSpecificOnBegin
+  end
+
+  #Does nothing.
+  def xsd_writeDeclarationSpecificOnEnd
+  end
+
+  #Does nothing.
+  def xsd_writeConstructors
+  end
+
+  #write java package declaration
+  # (Uses xsd_qualifiedName)
+  #
+  #Example:
+  #* package aPackage;
+  #* package aPackage.aPackage2;
+  #* //package --none--
+  #def xsd_writePackageDeclaration(&block)
+  #  p = umlx_package
+  #  if p.nil? || p.umlx_isARootNamespace?
+  #    write("//package --none--;\n")
+  #  else
+  #    write("package #{p.xsd_qualifiedName};\n")
+  #  end
+  #  yield
+  #end
+
+  #write java extends instructions is necessary
+  # (Uses xsd_qualifiedName)
+  #
+  #Example:
+  #   extends Class2,Class3
+  def xsd_writeExtends(&block)
+    pre=""
+    post=""
+    tab=""
+    uml_generalization.each { |g|
+      pre+=%{#{tab}<xsd:complexContent>\n#{tab}  <xsd:extension base="#{g.uml_general_one.xsd_qualifiedName}">\n}
+      post+=%{#{tab}  </xsd:extension>\n#{tab}</xsd:complexContent>\n}
+      tab=tab+"  "
+    }
+    write(pre)
+    yield
+    write(post)
+  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 xsd_writeImports
+    xsd_dependencies.each {|dep|
+      puts(%{<xsd:include schemaLocation="#{dep}"/>})
+    
+    }
+  
+  
+  
+    setOfImport=Set.new
+    xsd_import.each { |imp|
+      setOfImport<< imp
+    }
+    JAVA_DEFAULT_IMPORTS.each { |c|
+      setOfImport<< c
+    }
+    if(JAVA_IMPORT_COMPUTED_DEPENDENCIES)
+      umlx_computeDirectDepencies().each { |c|
+        m=c.xsd_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?)
+      # 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.xsd_qualifiedName;
+      end
+    end
+
+    mtk_protected(Mrdf_Resource::NOREVERSE,"imports") {
+      setOfImport.sort { |a,b| a <=> b}.each {|imp|
+        write("<!-- import #{imp}; -->\n");
+      }
+    }
+  end
+
+  #default java imports
+  #JAVA_DEFAULT_IMPORTS=[  ];
+
+  #iterate xsd_write on operations
+  #def xsd_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.xsd_Name.to_s <=> b.xsd_Name.to_s }.each { |o| o.xsd_write}
+  #end
+
+  #iterate xsd_write on attributes
+  #
+  #NOTE
+  #* no attribute is generated for an interface
+  #* getter/setter// are not handled here (see xsd_transform!).
+  def xsd_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
+    write(%{    <xsd:sequence>\n})
+    uml_ownedAttribute.sort { |a,b| a.xsd_Name.to_s <=> b.xsd_Name.to_s }.each { |o| o.xsd_writeProperty}
+    write(%{    </xsd:sequence>\n})
+  end
+end
+
+module Muml_Stereotype_Create
+  def xsd_write
+    write("\n")
+    xsd_writeAnnotation
+    xsd_writeMethodModifiers
+
+    #write("#{uml_class_one.xsd_Name}")
+    write("#{uml_ownedOperation_inv_one.xsd_Name}")
+
+    xsd_writeMethodParameters
+    xsd_writeMethodThrows
+    xsd_writeMethodBody
+  end
+end
+
+module Muml_Operation
+  rdf_safe_attr_reader_many :xsd_getter_property
+  rdf_safe_attr_reader_many :xsd_setter_property
+  include Mxsd_Annotation
+
+  #Attribut pouvant contenir le code java de la methode.
+  #Utilise lorsque le xsd_code est calcul? automatiquement.
+  rdf_safe_attr_reader_many :xsd_code
+
+  #is operation synchronised
+  rdf_safe_attr_reader_many :xsd_isSynchronised
+
+  #write java operation skeleton.
+  # (Uses xsd_writeMethodModifiers, xsd_writeMethodReturnType, xsd_writeMethodParameters, xsd_writeMethodThrows, xsd_writeMethodBody)
+  def xsd_write
+    write("\n")
+    #xsd_writeJavadoc
+    xsd_writeAnnotation
+    xsd_writeMethodModifiers
+
+    if(umlx_isConstructor?)
+      write("#{umlx_class_one.xsd_Name}")
+    else
+      xsd_writeMethodReturnType
+      write("#{xsd_Name}")
+    end
+    xsd_writeMethodParameters
+    xsd_writeMethodThrows
+    xsd_writeMethodBody
+  end
+
+  #write java method modifiers.
+  # (Uses xsd_writeAbstract, xsd_visibilityModifiers, xsd_writeStaticModifiers)
+  # Visibility is not generated for interfaces (to make checkstyle happy)
+  #Example:
+  #* abstract public
+  #* public static
+  def xsd_writeMethodModifiers
+
+
+    if !umlx_class_one.kind_of?(Muml_Interface)
+      uml_visibility.each { |v|
+        write(v.xsd_visibilityModifiers)
+      }
+    end
+    xsd_writeStaticModifier
+    xsd_writeAbstract
+    write "synchronized "if xsd_isSynchronised?
+
+    #xsd_writeModifiers
+    #abstract synchronized ...
+    #TODO uml_classifier_isAbstract
+  end
+
+  #write abstract keyword if necessary.
+  def xsd_writeAbstract
+    write("abstract ") if uml_isAbstract?
+  end
+
+  #write method return type
+  # (Uses xsd_writeParameterType)
+  def xsd_writeMethodReturnType
+    xsd_writeParameterType(umlx_returnResult_one0)
+  end
+
+  #write java type parameter (without the name)
+  #
+  #Example:
+  #* void
+  #* int
+  #* pack1.Class1
+  def xsd_writeParameterType(fp)
+    if (fp.nil?)
+      write("void ")
+    else
+      fp.xsd_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 xsd_writeMethodBody
+    if uml_isAbstract? || context[:xsd_interface]
+      write(";\n")
+    else
+      write("{");
+      mtk_protected(Mrdf_Resource::NOREVERSE) {
+        if ! xsd_code_one0.nil?
+          write xsd_code
+        else
+          xsd_writeMethodBodyNotImplemented
+        end
+      }
+      write("}\n");
+    end
+  end
+
+  #writes default code for a method not implemented
+  def xsd_writeMethodBodyNotImplemented
+    write <<END
+  //TODO: implement method body
+  throw new java.lang.RuntimeException("[operation \\"#{xsd_Name}\\"not implemented]");
+END
+  end
+
+  # write method throw clause.
+  #  (Uses xsd_qualifiedName )
+  #
+  # Example:
+  # * throws java.lang.Exception
+  def xsd_writeMethodThrows
+    sep=" throws "
+
+    uml_raisedException.each { |exception|
+      write(sep);
+      write(exception.xsd_qualifiedName)
+      sep=","
+    }
+  end
+
+  #write method parameters
+  #
+  #Example:
+  #* ()
+  #* (int x)
+  #* (pack1.Class1 xyz, String z)
+  def xsd_writeMethodParameters
+    write("(")
+    sep=""
+    uml_ownedParameter.each { |op|
+      next if op.uml_direction_one.isReturn?
+      write(sep)
+      sep=","
+      op.xsd_write
+    }
+    write(")")
+  end
+end
+
+module Muml_Property
+  include Mxsd_Annotation
+  rdf_safe_attr_reader_many :xsd_AttributeGlobalSetter
+  rdf_safe_attr_reader_many :xsd_AttributeGlobalGetter
+
+  #Attribut pouvant contenir la valeur initiale.
+  #Utilise lorsque le xsd_code est calcul? automatiquement.
+  rdf_safe_attr_reader_many :xsd_code
+
+  #Transient attribute
+  rdf_safe_attr_reader_many :xsd_isTransient
+
+  #is persistent (in database)
+  rdf_safe_attr_reader_many :db_isTransient
+
+  #property is final
+  rdf_safe_attr_reader_many :xsd_isFinal
+
+  #Methode vide
+  def xsd_writePropertyComment
+  end
+  #Methode vide
+  def xsd_writeGetterComment
+  end
+  #Methode vide
+  def xsd_writeSetterComment
+  end
+
+  def xsd_writeMaxOccurs
+    return if umlx_upperValueIsOne?
+    write(%{ maxOccurs="})
+    u=uml_upperValue.to_s
+    if(u=="-1")
+      write("unbounded")
+    else
+      write(u)
+    end
+    write(%{"})
+  end
+  def xsd_writeMinOccurs
+    return if umlx_lowerValueIsOne?
+    write(%{ minOccurs="})
+    u=uml_lowerValue.to_s
+    if(u=="-1")
+      write("unbounded")
+    else
+      write(u)
+    end
+    write(%{"})
+
+  end	
+  #write java attribute variable
+  # (Uses xsd_writePropertyComment, xsd_writePropertyModifiers ,xsd_propertyRoleType,xsd_NameProperty)
+  #
+  #NOTE:
+  #* getter/setter/... methods are handled by model transformation
+  def xsd_writeProperty
+    write(%{      <xsd:element name="#{xsd_Name}" type="#{uml_type_one.xsd_qualifiedName}"})
+    xsd_writeMinOccurs
+    xsd_writeMaxOccurs
+    write(%{/>\n})
+    #    return
+    #    if !uml_isDerived?
+    #      xsd_writePropertyComment
+    #      xsd_writeAnnotation
+    #      write("  ");
+    #      xsd_writePropertyModifiers
+    #      write("#{xsd_propertyAssociationType}")
+    #      write(" #{xsd_NameProperty}")
+    #
+    #      if !xsd_code.empty?
+    #        write"= #{xsd_code}"
+    #      elsif(context[:xsd_generateSetAttributeInitializer])
+    #        if (!umlx_upperValueIsOne?) && uml_qualifier.empty? && xsd_use_Arrays?
+    #          write("= new ");
+    #          write(uml_type_one.xsd_qualifiedName)
+    #          write("[1]")
+    #        elsif (!umlx_upperValueIsOne?) && uml_qualifier.empty?
+    #          write("= new ");
+    #          write(xsd_propertyAssociationConcreteType)
+    #          write("()")
+    #        elsif umlx_upperValueIsOne? && !uml_qualifier.empty?
+    #          write("= new ");
+    #          write(xsd_propertyAssociationConcreteType)
+    #          write("()")
+    #        elsif !umlx_upperValueIsOne? && !uml_qualifier.empty?
+    #          #write("= new ");
+    #          #write(xsd_propertyAssociationConcreteType)
+    #          #write("()")
+    #        end
+    #      end
+    #      write(";\n")
+    #    end
+  end
+
+
+
+  #write java modifiers if needed (public, static, ...)
+  # (Uses xsd_visibilityModifiers, xsd_writeStaticModifier)
+  # example: private static    final   transient long
+  def xsd_writePropertyModifiers
+
+    uml_visibility.each { |v|
+      write(v.xsd_visibilityModifiers)
+    }
+    xsd_writeStaticModifier
+    xsd_writeFinalModifier
+    xsd_writeTransient
+  end
+
+  def xsd_writeFinalModifier
+    return unless xsd_isFinal?
+    write "final "
+  end
+
+  #write java transient modifier if needed.
+  def xsd_writeTransient
+    return unless xsd_isTransient?
+    write("transient ")
+  end
+
+end
+
+
+
+module Muml_TypedElement
+  rdf_safe_attr_reader_many :xsd_use_Arrays
+
+  #return java property type.
+  # (Uses xsd_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 xsd_propertyRoleConcreteType
+    return xsd_getCollectionMapping.addCollectionImplem(
+      uml_type.empty? ? "Integer /* TODO: FIX:undefined type in uml model */ " : uml_type_one.xsd_qualifiedName )
+  end
+
+  def xsd_propertyRoleType
+    return xsd_getCollectionMapping.addCollectionInterface(
+      uml_type.empty? ? "Integer /* TODO: FIX:undefined type in uml model */ " : uml_type_one.xsd_qualifiedName )
+  end
+
+  def xsd_propertyAssociationConcreteType
+    return xsd_propertyRoleConcreteType if uml_qualifier.empty?
+    j="java.util.Hashtable<"
+    sep_next=""
+    uml_qualifier.each { |key|
+      j=j+sep_next+key.xsd_propertyRoleConcreteType
+      sep_next=","
+    }
+    j=j+","+xsd_propertyRoleConcreteType+">"
+    return j
+  end
+  def xsd_propertyAssociationType
+    return xsd_propertyRoleType if uml_qualifier.empty?
+    j="java.util.Hashtable<"
+    sep_next=""
+    uml_qualifier.each { |key|
+      j=j+sep_next+key.xsd_propertyRoleType
+      sep_next=","
+    }
+    j=j+","+xsd_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 xsd_qualifiedName
+    return super if kind_of?(Muml_Enumeration)
+
+    return DatatypeMapping.instance.getMapping(self).xsd_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 xsd_qualifiedName # retry
+  end
+end
+
+module Mrdf_Resource
+  #return true if java generator should totaly ignore this element.
+  #
+  #NOTE:
+  #* Default implementation returns false
+  def xsd_ignoreMe?
+    return false
+  end
+end
+
+#module Muml_ClassifierTemplateParameter
+#	def umlx_hierarchy
+#		return nil
+#	end
+#	def xsd_ignoreMe?
+#		return true
+#	end
+#end
+
+
+
+
+module Muml_Interface
+
+  #does nothing
+  def xsd_writeImplements
+  end
+
+  #write java interface keyword and interface name
+  #
+  #Example:
+  #* interface Interface1
+  #  def xsd_writeMetaClassName
+  #    write("interface #{xsd_Name}")
+  #  end
+
+  def xsd_makeSerializable!
+    #xsd_implements_add("java.io.Serializable");
+    s=umlx_getOrCreateClass("java.io.Serializable")
+    umlx_createAndAddGeneralization(s)
+  end
+end
+