ontomde-java 2.0.0

data/lib/ontomde-java/jpdl/main.rdoc

@@ -0,0 +1,2 @@
+
+TODO: documentation 

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

@@ -0,0 +1,316 @@
+
+
+#module Muml_Classifier
+#  STRUTS_APPLY_TO_PARAM="applyTo"
+#  STRUTS_APPLY_TO_PROP="ApplyTo"
+#end
+
+module Muml_Operation
+  rdf_safe_attr_reader_many :bpm_bizOperationReverse
+end
+
+module Muml_Parameter
+  #the method parameter
+  rdf_safe_attr_reader_many :bpm_sourceParameter
+end
+
+
+module Mrdf_Repository
+  def bpm_handleProcessMethods!
+    #return unless context[:withGenerateMethodForm]
+    uml_Class_all.each { |c|
+      next unless c.kind_of?(Muml_Class)
+      c.uml_ownedOperation.each {|biz|
+        next unless biz.kind_of?(Muml_Operation)
+        #next unless biz.umlx_businessMethod?
+
+        next if biz.umlx_isConstructor?
+        bpm_processMethods(c, biz) if biz.umlx_hasStereotype?("Process")
+        c.bpm_asyncMethods(biz) if biz.umlx_hasStereotype?("Async")
+        c.bpm_callbackMethods(biz) if biz.umlx_hasStereotype?("Callback")
+      }}
+  end
+
+
+  def bpm_processMethods(c, biz)
+
+    p=c.umlx_package
+    if p.nil?
+      log.error{"Model modification required !!! class #{c} is in root model element. Classes should be in a package."}
+      next
+    end
+    #Type de retour dans le mod�le
+    initialReturnParam = biz.uml_getReturnParameter
+    mpc=java_getClassWithQualifiedName("#{c.umlx_owner_one.java_qualifiedName}.#{biz.java_Name}")
+    mpc=p.umlx_createAndAddClass(biz.rdf_uri+"_proc") if mpc.nil?
+    mpc.umlx_businessMethod=RDF_TRUE
+    mpc.bpm_addAllOperationAggregateParameterClass!(biz)
+    code=%{ #{mpc.java_qualifiedName} proc=new #{mpc.java_qualifiedName}();}
+    biz.uml_ownedParameter.each { |param|
+      code=code+"proc.set#{param.java_NameBean}(#{param.java_Name});\n"
+    }
+
+    #Set the right Return Type on the Process
+    #If already specified in the Process definition, not overhide
+    #find the corresponding process
+    self.each { |k,p|
+      next if !p.kind_of?(Mbpm_process)
+      if "#{p.bpm_processName}" == "#{mpc.java_qualifiedName}"
+        # bpm_processReturnType is a string
+        p.bpm_processReturnType = initialReturnParam.uml_type.to_s if !initialReturnParam.nil? && p.bpm_processReturnType_one0.nil?
+        break
+      end
+    }
+
+    #If return set handler
+    code_getCallBackMethod = ""
+    if !initialReturnParam.nil?
+      c.bpm_manageAsynchronousMethods(biz)
+      code_getCallBackMethod = "handler"
+    end
+
+
+    #Modifiy the code of the method to manage the asynchronous
+    code=code+"proc.persist();proc.startAsynchronously(#{code_getCallBackMethod});\n"
+    biz.java_code=code
+
+    #Ajoute un champ calcule pour la visualization de la console
+    console=mpc.umlx_createAndAddProperty(mpc.rdf_uri+"_console","console")
+    console.uml_isDerived=RDF_TRUE
+    console.uml_type=mpc.umlx_getOrCreateDataType("URL")
+    mpc.java_addAccessorsFor!(console)
+    getter = console.java_AttributeGlobalGetter
+    getter[0].java_code = <<END_OF_STRING
+    if (this.getProcessId() != null) {
+        return "/ontomde-bpm-console/processimage?id=" + this.getProcessId();
+    } else {
+        return "#";
+    }
+END_OF_STRING
+
+
+    #    biz.uml_appliedStereotype.each {|s|
+    #      #TODO: utiliser processImpl
+    #      puts "add stereotype #{s} to #{mpc}::#{mpc.class}"
+    #      mpc.uml_appliedStereotype_add(s)
+    #    }
+
+  end
+
+
+end
+
+module Muml_Class
+
+  alias super_jpa_addStdImports! jpa_addStdImports!
+  def jpa_addStdImports!
+    super_jpa_addStdImports!
+
+    java_import_add("xmda.bpm.api.XmdaCallbackHandler")
+    java_import_add("xmda.bpm.api.client.EntityInstanceDescription")
+    java_import_add("xmda.bpm.api.client.EntityTaskDescription")
+    java_import_add("xmda.bpm.api.client.EntityTaskWithoutCallbackDescription")
+    java_import_add("xmda.bpm.api.jms.JmsCallbackHandler")
+    java_import_add(::DB::EntityGenericInterface)
+
+  end
+
+  #Ajoute une m�thode utilitaire pour r�cup�rer un handler correspondant � la m�thode
+  def bpm_callbackMethods(biz)
+    c=self
+    p=c.umlx_package
+    if p.nil?
+      log.error{"Model modification required !!! class #{c} is in root model element. Classes should be in a package."}
+      next
+    end
+    biz.java_annotation_add(%{@xmda.common.Callback})
+    type_callback=biz.bpm_callbackType
+
+    m=c.umlx_createAndAddOperation(biz.rdf_uri+"_handler","getOntomdeHandlerFor#{biz.uml_name}")#+self.java_NameBean)
+    m.uml_isStatic=RDF_TRUE
+    #m.uml_class=self
+    m.uml_visibility=Cuml_VisibilityKind::Public
+    #m.uml_isStatic=RDF_TRUE
+
+    param=m.umlx_createAndAddParameter(m.rdf_uri+"_this","_this")
+    i=c.umlx_getOrCreateInterface(DB::EntityInterface)
+    i.java_isGeneric=RDF_TRUE
+    param.uml_type=i
+    param.uml_direction=Cuml_ParameterDirectionKind::In
+    param.uml_upperValue=umlx_literal(1)
+    param.uml_lowerValue=umlx_literal(1)
+
+    rp=m.umlx_createAndAddParameter(m.rdf_uri+"_ret_param","return")
+    rp.uml_direction=Cuml_ParameterDirectionKind::Return
+    rp.uml_upperValue=umlx_literal(1)
+    rp.uml_lowerValue=umlx_literal(1)
+    i=c.umlx_getOrCreateInterface("xmda.bpm.api.XmdaCallbackHandler<#{type_callback}>")
+    i.java_isGeneric=RDF_TRUE
+    rp.uml_type=i
+    rp.uml_isOrdered=RDF_TRUE
+
+    m.java_annotation_add(%{@SuppressWarnings("unchecked")})
+
+    m.java_code=<<END_OF_STRING
+    return JmsCallbackHandler.Factory.createCallbackHandler(xmda.bpm.async.AsyncUtils.createAsyncTaskDescription(_this,"#{biz.uml_name}", new String[] {#{type_callback}.class.getName()}));
+END_OF_STRING
+
+  end
+
+  def bpm_manageAsynchronousMethods(biz, not_delete_param=false)
+    returnParam = nil
+    biz.uml_returnResult.each { |p|
+      #pour RSM (non conformite de l'export)
+      next unless p.uml_direction_one.isReturn?
+      returnParam=p
+      biz.uml_returnResult.delete(p) if !not_delete_param
+    }
+    biz.uml_ownedParameter.each { |p|
+      next unless p.uml_direction_one.isReturn?
+      returnParam=p
+      biz.uml_ownedParameter.delete(p) if !not_delete_param
+    }
+    return if returnParam.nil?
+
+    downcaseName=biz.uml_name_one0
+    if downcaseName[0..0].downcase!=downcaseName[0..0]
+      downcaseName="#{downcaseName[0..0].downcase}#{downcaseName[1,downcaseName.length]}"
+    end
+
+    param=biz.umlx_createAndAddParameter(biz.rdf_uri+"_handler_param","handler")
+    i=self.umlx_getOrCreateInterface("xmda.bpm.api.XmdaCallbackHandler<#{returnParam.uml_type}>")
+    i.java_isGeneric=RDF_TRUE
+    param.uml_type=i
+    param.uml_direction=Cuml_ParameterDirectionKind::In
+  end
+
+
+  def bpm_asyncMethods(biz)
+    biz.java_annotation_add(%{@xmda.bpm.async.Async})
+    bpm_manageAsynchronousMethods(biz, true)
+  end
+
+end
+
+module Muml_Operation
+
+  def uml_getReturnParameter
+    fp=nil
+    uml_returnResult.each { |p|
+      #pour RSM (non conformite de l'export)
+      next unless p.uml_direction_one.isReturn?
+      fp=p
+    }
+    uml_ownedParameter.each { |p|
+      next unless p.uml_direction_one.isReturn?
+      fp=p
+    }
+    return fp
+  end
+
+  def bpm_returnType
+    fp = uml_getReturnParameter
+    if !fp
+      return "#{BPM::NullReturn}"
+    else
+      return "#{fp.uml_type}"
+    end
+  end
+
+  def bpm_callbackType
+    fp=nil
+    uml_ownedParameter.each { |p|
+      next if p.uml_direction_one.isReturn?
+      if !fp.nil?
+        log.error("Method #{self.uml_name} : Should not define Callback method with multiple parameters")
+        raise Warning.new(),"Method #{self.uml_name} : Should not define Callback method with multiple parameters"
+      else
+        fp=p
+      end
+
+    }
+    if !fp
+      return "#{BPM::NullReturn}"
+    else
+      return "#{fp.uml_type}"
+    end
+  end
+
+end
+
+
+module Muml_Classifier
+
+  rdf_safe_attr_reader_many :bpm_bizOperation
+  #
+  #Creates a class for every business method holding every parameters
+  #and
+  #
+  #
+
+  #STRUTS_RESULT_PARAM_NAME="_result"
+
+  def bpm_addAllOperationAggregateParameterClass!(biz)
+    mpc=self
+    mpc.bpm_bizOperation=biz
+    biz.bpm_bizOperationReverse_add(mpc)
+    #biz.bpm_bizForm=mpc
+    #mpc.uml_name="#{biz.umlx_owner_one.java_Name}#{biz.java_Name}PROC"
+    #method process is expected to be unique
+    #in namespace
+    mpc.uml_name="#{biz.java_Name.to_s}"
+
+    (biz.uml_ownedParameter+biz.uml_returnResult).each { |param|
+      next if param.uml_direction_one.isReturn?
+      mpcp=mpc.umlx_createAndAddProperty(param.rdf_uri+"_proc")
+      param.umlx_copyToAttributeProperty(mpcp)
+      mpcp.uml_name= param.uml_direction_one.isReturn? ? STRUTS_RESULT_PARAM_NAME : param.uml_name
+    }
+    mpc.bpm_addApplyToParameter!(biz)
+    mpc.bpm_addProceed!(biz)
+    #mpc.apaCom_addLogger!
+  end
+
+  def bpm_addApplyToParameter!(biz)
+    return
+    mpc=self
+    m,m1,m2=mpc.umlx_createAndAddAssociation(mpc.rdf_uri+"_apply",biz.umlx_owner_one)
+    m1.uml_name=STRUTS_APPLY_TO_PARAM
+    m2.uml_name="#{STRUTS_APPLY_TO_PARAM}_inv"
+  end
+
+  def bpm_addProceed!(biz)
+    return
+    mpc=self
+    cpt=mpc.umlx_createAndAddOperation(mpc.rdf_uri+"_proceed","proceed")
+    params=""; sep=""
+    hasRP=false
+    (biz.uml_ownedParameter+biz.uml_returnResult).each { |param|
+      if param.uml_direction_one.isReturn?
+        hasRP=true
+        next
+      end
+      params="#{params}#{sep}#{param.java_Name}"
+      sep=","
+    }
+    if(biz.uml_raisedException.empty?)
+      cpt.java_code=%{
+			#{hasRP ? "#{STRUTS_RESULT_PARAM_NAME}=" : ""} #{STRUTS_APPLY_TO_PARAM}.#{biz.java_Name}(#{params});
+      }
+    else
+      cpt.java_code=%{
+		try {
+			//log.error("before biz method");
+			//log.error("applyTo="+#{STRUTS_APPLY_TO_PARAM});
+      #{hasRP ? "#{STRUTS_RESULT_PARAM_NAME}=" : ""} #{STRUTS_APPLY_TO_PARAM}.#{biz.java_Name}(#{params});
+      //log.error("after biz method");
+      //log.error("result="+#{hasRP ? STRUTS_RESULT_PARAM_NAME : %{"-none-"}});
+		} catch(Exception e) {
+			//TODO: implement proper exception handling
+			throw new java.lang.RuntimeException(e);
+		}
+      }
+    end
+
+  end
+end

data/lib/ontomde-java/kbjava.rb

@@ -0,0 +1,6 @@
+h=File.dirname(__FILE__)
+
+require "ontomde-uml2/kb"
+require "ontomde-java"
+
+require "ontomde-java/kbjava/rdfToJava.rb"

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

@@ -0,0 +1,407 @@
+#This module is meant to be applied
+#to a protege 2000 knowledge model
+class Crdf_ProtegeDataModel < Crdf_Repository
+
+  #uml model used to generate this protege data model
+  #attr :umlSourceModel
+  attr_accessor :kbjava_umlSourceModel
+
+  #Generates a DataSet
+  #default generation path may be overriden by providing appropriate context.
+  def kbjava_generate
+    mtk_default_context(:dataTestClassName=>'UserData',:dataTestPackageName => 'xmda.test') {
+
+      dc=@kbjava_umlSourceModel.umlx_reserved_model.umlx_getOrCreateClass("#{context[:dataTestPackageName]}.#{context[:dataTestClassName]}")
+      dc.umlx_external=RDF_FALSE
+
+      #No Gui is provided for TestData (class is too big)
+      dc.umlx_businessMethod=RDF_FALSE
+
+      #UserData must be transient because UserData links
+      #eventually to many many many objects and this
+      #would generate has many columns in database
+      #and as many joins.
+      dc.db_isTransient=RDF_TRUE
+
+      kbjava_addData!(dc)
+    }
+  end
+
+
+
+  #writes all in one java class which will contain all of
+  #our test instances loaded from source protege data model.
+  def kbjava_addData!(umlDataClass)
+    #write "package #{context[:dataTestPackageName]};\n"
+    #write("public class #{context[:dataTestClassName]} {\n")
+
+    #mtk_protected("converter") {
+    umlDataClass.java_customCode= <<END
+ private static java.text.SimpleDateFormat dfCalendar= new java.text.SimpleDateFormat("yyyy/MM/dd",java.util.Locale.ENGLISH);
+ private static java.text.SimpleDateFormat dfTimestamp= new java.text.SimpleDateFormat("yyyy/MM/dd",java.util.Locale.ENGLISH);
+  public java.util.Date convertCalendar(final String s) {
+	try  {
+	return dfCalendar.parse(s) ;
+	} catch (java.text.ParseException e) {
+		throw new java.lang.RuntimeException(e);
+	}
+  }
+  public java.util.Date convertTimestamp(final String s) {
+	try  {
+	return dfTimestamp.parse(s) ;
+	} catch (java.text.ParseException e) {
+		throw new java.lang.RuntimeException(e);
+	}
+  }
+
+END
+
+    #}
+    [true,false].each {|stepOne|
+      self.each { |k,c|
+        next unless c.kbjava_isUmlObject?
+        c.kbjava_writeJavaObject(@kbjava_umlSourceModel, self,umlDataClass,stepOne)
+      }}
+    #write "}"
+    #@kbjava_umlSourceModel.kbjava_computeCoverage
+  end
+
+  def kbjava_generateJavaJunit!
+    self.each { |k,c|
+      next unless c.kind_of?(Mkb_UML_TEST_DATA_SET)
+      uml_type=c.rdf_type.kbjava_uml_model_element(@kbjava_umlSourceModel)
+      p=uml_type.umlx_owner_one
+      p=p.umlx_getOrCreatePackage(context[:kbjava_junitSubPackage,"junitUseCase"],p)
+      p=p.umlx_getOrCreatePackage(uml_type.java_Name.to_s,p)
+
+      n=p.umlx_createAndAddClass("#{c.rdf_uri}_junit","junit#{c.kb_UML_DATA_SET_NAME}")
+
+      #Provide a Gui
+      n.umlx_businessMethod=RDF_TRUE
+      #puts "n=#{n.uml_name} busniess=#{n.umlx_businessMethod?}"
+      #n.apaCom_addLogger!
+      n.db_isTransient=RDF_TRUE
+      #n.struts_isForm=RDF_FALSE
+      n.umlx_external=RDF_FALSE
+      n.java_import='org.junit.Test'
+      #n.java_import_add('java.io.PrintWriter');
+      #n.java_import_add('java.io.StringWriter');
+      n.java_isATestFile=RDF_TRUE
+
+      #also avoid org.junit.* import notused warning in Eclipse
+      n.java_customCode="@Test\npublic void replaceWithMeaningfulTest(){}\n"
+
+      m=n.umlx_createAndAddOperation(n.rdf_uri+"merge","merge");
+      #TODO merge referenced items
+      m.java_code="return this;"
+      p=m.umlx_createAndAddReturnParameter(m.rdf_uri+'_ret',"return")
+      p.uml_type=n
+      m.umlx_businessMethod=RDF_FALSE
+
+
+      persist=n.umlx_createAndAddOperation(n.rdf_uri+"persist","persist");
+      persist.java_code="" # #{java_debug(%{log.debug("persisting referenced persistent elements");}\n}"
+      p=persist.umlx_createAndAddReturnParameter(persist.rdf_uri+'_ret',"return")
+      p.uml_type=n
+      persist.umlx_businessMethod=RDF_FALSE
+
+
+      #v=n.umlx_createAndAddProperty(n.rdf_uri+"__source","source");
+
+      #ds="#{context[:dataTestPackageName]}.#{context[:dataTestClassName]}"
+      #TODO: remove hard coded
+      ds="xmda.test.UserData"
+      #v.uml_type=n.umlx_getOrCreateClass(ds)
+      #v.java_code="null"
+
+      j=<<END
+	// using one single source object
+	// enables objects retrieved to be linked together.
+	// Objects retrieved with a new source will *not* be linked together.
+	#{ds} source=new #{ds}();
+END
+      c.kb_UML_DATA.each { |d|
+        if  d.kb_UML_INSTANCE_ALIAS.empty?
+          log.warn("data ignored in junit #{c} because of missing UML_INSTANCE_ALIAS")
+          next
+        end
+        u=d.rdf_type.kbjava_uml_model_element(@kbjava_umlSourceModel)
+        p=n.umlx_createAndAddProperty(n.rdf_uri+d.rdf_uri,"#{d.kb_UML_INSTANCE_ALIAS}");
+        p.uml_type=u
+        p.uml_isReadOnly=RDF_TRUE
+        p.java_code="null"
+
+        j="#{j}\n	set#{p.java_NameBean}(source.get#{p.java_NameBean}());"
+        persist.java_code="#{persist.java_code.to_s} get#{p.java_NameBean}().persist();\n"
+      }
+
+      m=n.umlx_createAndAddOperation(n.rdf_uri+"initData","initData")
+      m.umlx_businessMethod=RDF_FALSE
+      m.java_code="#{j} return this;"
+      m.java_annotation_add(%{@SuppressWarnings("unused")})
+      p=m.umlx_createAndAddReturnParameter(m.rdf_uri+'_ret',"return")
+      p.uml_type=n
+
+      persist.java_code="#{persist.java_code.to_s} return this;\n"
+    }
+  end
+
+end
+
+class Ckb_UML_SLOT < ::Crdf_Property
+end
+
+#
+class Ckb_UML_METACLASS < Crdfs_Class
+  def kbjava_uml_model_element(umlSourceModelParam)
+    r=umlSourceModelParam[::UriNamespace.instance.urialias(@kb_UML_URI.to_s)]
+    return r unless r.nil?
+    
+    # not found but it is normal
+    return nil if Mrdf_Repository::SOA_URI_SET.include?(@kb_UML_URI.to_s) 
+    
+    puts("WARNING: uml item not found for uri=--#{@kb_UML_URI}--")
+    return nil
+  end
+end
+
+class ::Crdfs_Class
+
+  def kbjava_umlSourceModel
+    return rdf_Repository.kbjava_umlSourceModel
+  end
+
+  #uml model used to generate this protege data model
+  rdf_safe_attr_reader_many :kbjava_property
+  #rdf_safe_attr_reader_many :kbjava_initMethod
+  def kbjava_writeJavaObject(umlSourceModelParam, dataSource,umlDataClass,stepOne)
+    if rdf_type.nil?
+      # object was created localy (it was not loaded from file)
+      return
+    end
+    uml_type=self.rdf_type.kbjava_uml_model_element(umlSourceModelParam)
+
+    return if uml_type.kind_of?(Muml_UseCase)
+    return if uml_type.nil? # element is not mapped to an uml class (soa:soa, ...)
+
+    if stepOne
+      # Create attributes and every init methods (body expected)
+      uml_type.kb_coverage_add(self)
+      p=umlDataClass.umlx_createAndAddProperty(umlDataClass.rdf_uri+kbjava_varName,kbjava_varName.to_s)
+      p.uml_type=uml_type
+      p.uml_visibility=  Cuml_VisibilityKind::Private
+      #p.java_noAccessors=RDF_TRUE
+      self.kbjava_property=p
+
+      #init method
+      #p=self.kbjava_property_one
+      #i=umlDataClass.umlx_createAndAddOperation(umlDataClass.rdf_uri+"init"+kbjava_varName,"init#{kbjava_varName}")
+      #i.uml_visibility=  kbjava_isPublic? ? Cuml_VisibilityKind::Public : Cuml_VisibilityKind::Private
+      #r=i.umlx_createAndAddReturnParameter(i.rdf_uri+"ret","_return")
+      #r.uml_type=p.uml_type_one
+      #self.kbjava_initMethod=i
+
+      umlDataClass.java_addGlobalGetter!(p)
+    else
+      # Create init methods body
+      p=self.kbjava_property_one
+      #i=self.kbjava_initMethod_one
+      i=p.java_AttributeGlobalGetter_one
+      #write "private #{uml_type.java_qualifiedName} #{kbjava_varName}=null;\n"
+      #write "#{kbjava_public ? "public" : "private"} #{uml_type.java_qualifiedName} get#{kbjava_varName}() {"
+      #p=self.kbjava_property_one
+      i.java_code= <<ENDinit
+	if(#{p.java_Name}==null){
+		#{p.java_Name}= new #{uml_type.java_qualifiedName}();
+		#{p.uml_type_one.java_qualifiedName} elt= #{p.java_Name};
+		#{mtk_stss{kbjava_writeJavaObjectSetters(dataSource)}}
+	}
+	return #{p.java_Name};
+ENDinit
+
+      # overide getter with init
+    end
+  end
+
+  # Returns test object variable name which will be used to store this test object.
+  # Return uri if test object has no name.
+  def kbjava_varName
+    return kbjava_aliasName.nil? ? uri : kbjava_aliasName
+  end
+
+  #
+  def kbjava_aliasName
+    s=@kb_UML_INSTANCE_ALIAS
+    return nil if s.nil?  || s.empty?
+    return s.to_s
+  end
+
+  def kbjava_isPublic?
+    return !kbjava_aliasName.nil?
+  end
+
+  def kbjava_uml_property_values(dataSource)
+    ret=Hash.new
+    instance_variables.each {
+      |m|
+      next if ["@kbjava_property","@kb_UML_URI","@kb_UML_LABEL","@rdfs_label","@ext_isReferencedBy","@rdfs_subClassOf", "@kb_UML_INSTANCE_ALIAS","@kb_UML_REFERENCED_USE_CASE","@kb_inv_UML_REFERENCED_USE_CASE","@kb_UML_USE_CASE_ENV"].include?(m)
+
+      var = instance_variable_get(m)
+      rawval = self.instance_variable_get(m)
+
+      next unless rawval.kind_of?(ArrayOrSingleElement)
+
+      protprop_ident=m[1,m.length] #remove leading @
+      protprop_uri=getRubyNameInverse(protprop_ident)
+      protprop=dataSource[protprop_uri]
+
+      umluri=protprop.instance_variable_get("@kb_UML_URI").to_s
+      umlurialiased=::UriNamespace.instance.urialias(umluri)
+      umlprop=kbjava_umlSourceModel[umlurialiased]
+
+      if umlprop.nil?
+        log.warn { "uml prop not found for slot '#{m}' umluri='#{umluri}' umluriprop='#{umlurialiased}'" }
+        next
+      end
+      ret[umlprop]=rawval
+    }
+    return ret
+  end
+
+  def kbjava_writeJavaObjectSetters(dataSource)
+    kbjava_uml_property_values(dataSource).each {
+      |umlprop,rawval|
+      umlprop.kb_coverage_add(rawval)
+      rawval.each {|v|
+        kbjava_writeJavaObjectSetter(umlprop,v)
+      }
+    }
+  end
+
+  def kbjava_writeJavaObjectSetter(umlprop,valitem)
+    return if umlprop.uml_name.empty?
+    return unless umlprop.umlx_isNavigable?
+
+    #t=umlprop.uml_type_one.java_qualifiedName
+
+    m=DatatypeMapping.instance.getMapping(umlprop.uml_type_one)
+    v=m.prot_convertToJava(umlprop,valitem)
+    #i=m.prot_init(umlprop,valitem)
+
+    #puts "i='#{i}'"
+    meth=umlprop.umlx_upperValueIsOne? ? "set" : "add"
+    #write "    #{i}/* tpl-kbjava01 */\n"
+    write "// read only " if umlprop.uml_isReadOnly?
+    write "    elt.#{meth}#{umlprop.java_NameBean}(#{v});\n"
+  end
+end
+
+module Muml_Element
+  rdf_safe_attr_reader_many :kb_coverage
+end
+module Mrdf_Repository
+  def kbjava_computeCoverage
+    puts "COVERAGE REPORT"
+    puts %{class|property|hit|min hit\n}
+    ret=Array.new
+    uml_Class_all.each { |c|
+
+      next if c.uml_isAbstract?
+      next if c.kind_of?(Cuml_Enumeration)
+      next if c.uml_ownedAttribute.empty?
+      puts %{#{c.uml_name}|id|#{c.kb_coverage.size}|1\n}
+      c.uml_ownedAttribute.each {|a|
+        max=a.uml_type_one.kind_of?(Muml_Enumeration) ? a.uml_type_one.uml_ownedLiteral.size : "1"
+        puts %{#{c.uml_name}|#{a.uml_name}|#{a.kb_coverage.size}|#{max}\n}
+        ret<< { "class" => c.uml_name,"property"=> a.uml_name, "hit" =>a.kb_coverage.size, "minhit" => max}
+      }
+
+    }
+    puts "COVERAGE REPORT END"
+    return ret
+  end
+end
+
+module Mrdf_Resource
+  def kbjava_isUmlObject?
+    c=self
+    # filters out Protege meta-model element
+    return false if (c.kind_of?(Ckb_UML_METACLASS))||(c.kind_of?(Ckb_UML_SLOT))
+    # filters out rdf root elements
+    return false if (c.class==Crdf_Resource) || (c.class==Crdf_Property)
+    return true
+  end
+end
+
+class DatatypeMapping
+  def prot_init(umlprop,valitem)
+    return ""
+  end
+end
+
+class DatatypeMappingText < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    return %{"#{valitem}"}
+  end
+end
+class DatatypeMappingInteger < DatatypeMappingOrdinal
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    #Remove leading 0 (octal)
+    return valitem.gsub(/^0*([0-9])/,'\1')
+  end
+end
+class DatatypeMappingLong < DatatypeMappingOrdinal
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    #Remove leading 0 (octal)
+    return valitem.gsub(/^0*([0-9])/,'\1')
+  end
+end
+class DatatypeMappingFile < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    # ??
+    return valitem
+  end
+end
+class DatatypeMappingBoolean < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    return valitem
+  end
+end
+class DatatypeMappingTimeStamp < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    return %{convertTimestamp("#{valitem}")}
+  end
+end
+class DatatypeMappingCalendar < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    return %{convertCalendar("#{valitem}")}
+  end
+end
+class DatatypeMappingGenericClass < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    return "#{valitem.kbjava_property_one.java_AttributeGlobalGetter_one.java_Name}()"
+  end
+  def prot_init(umlprop,valitem)
+    return ""
+    #return "init#{umlprop.java_NameBean}();/* #{umlprop.class} */"
+  end
+end
+class DatatypeMappingGenericEnum < DatatypeMapping
+  # Protege string to Java code conversions
+  def prot_convertToJava(umlprop,valitem)
+    lit=nil
+    umlprop.uml_type_one.uml_ownedLiteral.each { |i|
+      next if i.to_s!=valitem.to_s
+      lit=i
+    }
+    return "#{umlprop.uml_type_one.java_qualifiedName}.#{lit.java_Name}"
+  end
+end