ontomde-java 2.0.0

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

@@ -0,0 +1,43 @@
+#
+#  Contextualize feature is in alpha stage
+#
+
+module Mrdf_Repository
+def java_contextualizeStaticProperties!
+    uml_Class_all.each {|c|
+      next unless c.kind_of?(Muml_Class)
+      c.java_contextualizeMyStaticProperties!
+    }
+  end
+end
+
+module Muml_Classifier
+  def java_contextualizeMyStaticProperties!
+    o=umlx_getCompositeRec
+    return if o.nil?
+    
+    uml_ownedAttribute.each {|att|
+      next unless att.uml_isStatic?
+      oe=o.umlx_otherEnd
+      puts "compositeRec   #{oe} #{o.class.name} #{o} <X>--> #{self}"
+      att.uml_isStatic=RDF_FALSE
+      att.uml_isDerived=RDF_TRUE
+      att.uml_isReadOnly=RDF_TRUE
+      self.java_addAccessorsFor!(att)
+      att.java_AttributeGlobalGetter_one.java_code="return get#{oe.java_NameBean}().get#{att.java_NameBean}();"
+      
+#      owner.
+#      att.
+      
+    }
+    
+#    next unless uml_isStatic?
+#    ow=false
+#    uml_ownedElement.each { |elt|
+#      next unless elt.uml_isStatic?
+#      if(ow)
+#      
+#    }
+    
+  end
+end

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

@@ -0,0 +1,75 @@
+#For each model class, create an enum containing a list of assignable type.
+#
+module Muml_Element
+	JAVA_ENUM_INTERFACE_QNAME="xmda.java.JavaEnumSig"
+end
+
+
+module Mrdf_Repository
+	# generates an EnumAssignable for each model element.
+        # 
+        # Reference: #uml_Class_all, 
+	def java_addJavaEnumInterface!
+		return unless context[:java_addJavaEnumInterface]
+		uml_Class_all.each {|c|
+			next unless c.kind_of?(Muml_Enumeration)
+			i=c.java_getJavaEnumInterface
+			c.umlx_createAndAddImplementation(i)
+		}
+	end
+        
+        # adds enum for all assignable class types.
+        # 
+        # Reference: #uml_Class_all
+	def java_addEnumAssignable!
+		uml_Class_all.each {|c|
+			next if c.kind_of?(Muml_Enumeration)
+			next if c.umlx_external?
+			c.java_addEnumAssignable!
+		}
+	end
+end
+
+module Muml_Classifier
+	# Enum assignbable related to this model Element
+	rdf_safe_attr_reader_many :java_enumAssignableDataType
+
+
+	# String used to replace dot in enum literals
+	JAVA_MAGIC_DOT_STRING='_dot_'
+
+	# add an enum assignable for this model element
+	def java_addEnumAssignable!
+		#log.debug { "java_addEnumAssignable! for #{self}::#{self.class.name}" }
+		p=umlx_owner_one
+		p=p.umlx_getOrCreatePackage(context[:enumAssignableSubPackage,"enumCreate"],p)
+
+		ret=p.umlx_createAndAddEnumeration(self.rdf_uri+"_enumAssignable","#{uml_name} Assignable")
+		ret.umlx_createAndAddImplementation(java_getJavaEnumInterface)
+		self.java_enumAssignableDataType=ret
+
+		umlx_assignableClassifier.each { |c|
+			next if c.uml_isAbstract?
+			ret.umlx_createAndAddLiteral(c.java_qualifiedName.to_s.gsub(/\./,JAVA_MAGIC_DOT_STRING));
+		}
+
+		return ret
+	end
+        
+        # return enum interface for this model element. (creates it if necessary).
+	def java_getJavaEnumInterface
+		ret=umlx_getOrCreateInterface(JAVA_ENUM_INTERFACE_QNAME)
+		if ret.uml_ownedOperation.empty?
+			ret.umlx_external="false"
+			op=ret.umlx_createAndAddOperation("#{ret.rdf_uri}_name}","name")
+			r=op.umlx_createAndAddReturnParameter("#{op.rdf_uri}_ret","return")
+			r.uml_type=umlx_dataType_string
+                        op.umlx_businessMethod=RDF_FALSE
+		end
+		return ret
+	end
+
+
+end
+
+

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

@@ -0,0 +1,195 @@
+# define enum as string compatibility layer
+#
+# Feature introduced for FLEX for Java 1.5 / Java 1.4 interoperability
+#
+#
+
+module Mrdf_Repository
+  # adds enum compatibility properties which exposes property of enum type to be accessed trough string accessors.
+  #
+  #Reference: #uml_Class_all, #java_addEnumStringAttribute!, #java_addEnumCompatibilityLayerMethods!
+  def java_addEnumCompatibilityLayerProperties!
+    uml_Class_all.each {|c|
+      next unless c.kind_of?(Muml_Class)
+      c.uml_ownedAttribute.each {|e|
+        e.java_addEnumStringAttribute!
+      }
+    }
+  end
+        
+  # adds enum compatibility properties which exposes property of enum type to be accessed trough string accessors.
+  #
+  #Reference: #uml_Class_all, #java_addEnumCompatibilityLayerProperties!, #java_addEnumPostDeserialiseUpdate!
+  def java_addEnumCompatibilityLayerMethods!
+    uml_Class_all.each {|c|
+      next unless c.kind_of?(Muml_Class)
+      c.java_addEnumPostDeserialiseUpdate!
+    }
+  end
+end
+
+module Muml_Classifier
+  def java_isEnumStringMapping?(oa)
+    return !oa.umlx_stringMappingForEnum.empty?
+  end
+
+  def java_writeEnumStringMappingGetterCode(oa)
+    # getter for compatibility layer (enum visible as string)
+    enum_oa=oa.umlx_stringMappingForEnum_one
+    if  oa.umlx_upperValueIsOne?
+      write "return (#{enum_oa.java_NameProperty}==null) ? null : (#{enum_oa.java_NameProperty}.name());  "
+
+    else
+      write %{
+	java.util.Set<java.lang.String>  ret=new java.util.HashSet<java.lang.String>();
+	for ( java.util.Iterator<#{enum_oa.uml_type_one.java_qualifiedName}>  iter = #{enum_oa.java_NameProperty}.iterator(); iter.hasNext();) {
+		ret.add(iter.next().name());
+	}
+	return ret;\n}
+    end
+  end
+  def java_writeEnumStringMappingSetterCode(oa)
+    oa_enum=oa.umlx_stringMappingForEnum_one
+    #Note: throws a runtime exception if enum is not found
+    #Note: valueOf throws null pointer exception
+    if  oa.umlx_upperValueIsOne?
+      write "#{oa_enum.java_NameProperty}= #{getterParameterName(oa)}==null ? null : Enum.valueOf(#{oa_enum.uml_type_one.java_qualifiedName}.class,#{getterParameterName(oa)});"
+    else
+      # TODO: provide java implementation
+    end
+  end
+
+end
+module Muml_Property
+  #string version of this enum property
+  rdf_safe_attr_reader_many :umlx_stringMappingForEnum
+
+  #add string as enum compatibility layer string
+  def java_addEnumStringAttribute!
+    return unless uml_type_one.kind_of?(Muml_Enumeration)
+    c=umlx_owner_one
+    a=self
+    #log.debug { "adding attribute for #{self} #{c}" }
+    rr=c.umlx_createAndAddProperty(a.rdf_uri+"_asString",a.uml_name_one+"AsString")
+    rr.uml_type=c.umlx_dataType_string
+    rr.uml_visibility=::Cuml_VisibilityKind::Private
+
+    rr.umlx_stringMappingForEnum=a
+    rr.uml_isDerived=RDF_TRUE
+    rr.uml_upperValue=a.uml_upperValue
+    rr.uml_lowerValue=a.uml_lowerValue
+  end
+end
+
+module Muml_Class
+  #returns true if class has at least one enum property
+  #Inherited properties are not taken into account.
+  def java_hasEnumDirectProperties?
+    uml_ownedAttribute.each { |a|
+      return true if a.uml_type_one.kind_of?(Muml_Enumeration)
+    }
+    return false
+  end
+
+  def java_addEnumPostDeserialiseUpdate!
+    #TODO optimize
+    #return unless java_hasEnumDirectProperties?
+
+    #rr=umlx_createAndAddOperation(self.rdf_uri+"_"+"readResolve","readResolve")
+    #rr.uml_raisedException_add(umlx_getOrCreateClass("java.io.ObjectStreamException"))
+    #rr.uml_visibility=::Cuml_VisibilityKind::Private
+    #rr.java_code="updateEnumFromEnumAsString();\nreturn this;\n"
+
+    #rp=rr.umlx_createAndAddReturnParameter(rr.rdf_uri+"_ret")
+    #rp.uml_type=umlx_getOrCreateClass("java.lang.Object")
+
+
+    #u=umlx_createAndAddOperation(self.rdf_uri+"_"+"upd_Enum","updateEnumFromEnumAsString")
+
+
+    #code=%{Sy stem.out.println("readResolve #{java_qualifiedName}");\n}
+    #code=code+(uml_generalization.empty? ? "//" : "")+"super.#{u.java_Name}();\n"
+
+    uml_ownedAttribute.each { |a|
+      next unless a.uml_type_one.kind_of?(Muml_Enumeration)
+      a.java_setter_property_inv.each { |g|
+        g.java_code=g.java_code_one+<<END
+				\n#{a.umlx_stringMappingForEnum_one.java_Name}=#{a.java_Name}.name();
+END
+      }
+      a.umlx_stringMappingForEnum_one.java_getter_property_inv.each { |g|
+        #asString is not updated when loaded from base
+        g.java_code=%{#{a.umlx_stringMappingForEnum_one.java_Name}= #{a.java_Name}==null ? null : #{a.java_Name}.name();\n}+g.java_code_one
+      }
+      a.umlx_stringMappingForEnum_one.java_setter_property_inv.each { |g|
+        g.java_code=g.java_code_one+<<END
+				\n#{a.java_Name}=Enum.valueOf(#{a.uml_type_one.java_qualifiedName}.class,#{a.umlx_stringMappingForEnum_one.java_Name});
+END
+      }
+
+      #code=code+<<END
+      #if(#{a.umlx_stringMappingForEnum_one.java_Name}!=null) {
+      #	#{a.java_Name}=Enum.valueOf(#{a.uml_type_one.java_qualifiedName}.class,#{a.umlx_stringMappingForEnum_one.java_Name});
+      #} else {
+      #	#{a.java_Name}=null;
+      #}
+      #END
+    }
+    #u.java_code=code;
+
+    return
+  end
+
+end
+
+
+#	#Generates a custom serializer
+#	def java_addReadWriteExternal!
+#		return unless java_hasEnumDirectProperties?
+#		java_addReadExternal!
+#		java_addWriteExternal!
+#		write("super(output)")
+#	end
+#	def java_addReadExternal!
+#		m=umlx_createAndAddOperation(action.rdf_uri+"_"+"readExternal","readExternal")
+#		p=afo.umlx_createAndAddParameter(m.rdf_uri+"input","input")
+#		p.uml_class=umlx_getOrCreateClass("java.io.ObjectInput")
+#		m.uml_raisedException_add(umlx_getOrCreateClass("java.lang.ClassNotFoundException"))
+#		m.uml_raisedException_add(umlx_getOrCreateClass("java.io.IOException"))
+#		m.java_code=java_getReadExternalCode("input")
+#		return m
+#	end
+#	def java_addWriteExternal!
+#		m=umlx_createAndAddOperation(action.rdf_uri+"_"+"writeExternal","writeExternal")
+#		p=afo.umlx_createAndAddParameter(m.rdf_uri+"output","output")
+#		p.uml_class=umlx_getOrCreateClass("java.io.ObjectOuput")
+#		m.uml_raisedException_add(umlx_getOrCreateClass("java.io.IOException"))
+#		m.java_code=java_getWriteExternalCode("output")
+#		return m
+#	end
+#	def java_getWriteExternalCode(varname)
+#		code="super(#{varname});\n"
+#		uml_ownedAttribute.each { |a|
+#			//TODO: collection of Enumeration
+#			if(a.uml_type_one.kind_of?(Muml_Enumeration)) {
+#				code=code+"#{varname}.writeObject(#{a.java_Name}.name());\n"
+#			} else {
+#				code=code+"#{varname}.writeObject(#{a.java_Name});\n"
+#			}
+#		}
+#		return code
+#	end
+#	def java_getReadExternalCode(varname)
+#		code="super(#{varname});\n"
+#		uml_ownedAttribute.each { |a|
+#			//TODO: collection of Enumeration
+#			if(a.uml_type_one.kind_of?(Muml_Enumeration)) {
+#				code=code+"#{a.java_Name}=(#{a.uml_type_one.java_qualifiedName})Enum.value(#{a.uml_type_one.java_qualifiedName},(String)#{varname}.readObject());\n"
+#			} else {
+#				code=code+"#{a.java_Name}=(#{a.uml_type_one.java_qualifiedName})#{varname}.readObject();\n"
+#			}
+#		}
+#		return code
+#	end
+#
+#end

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

@@ -0,0 +1,91 @@
+module Muml_Classifier
+  
+  # adds a equals and a hash method to the current class.
+  # Signature is computed from attributes stereoptyped EqualsValue
+  # NOTE:
+  # method is not generated if there is no attribute stereotyped EqualsValue
+  def java_addEqualsAndHashOperations(callSuperEquals)
+    ret=Set.new
+    uml_ownedAttribute.each {|biz|
+      ret << biz if biz.umlx_hasStereotype?("EqualsValue")
+    }
+    if !ret.empty?
+      puts "generate hash and equals for #{self.java_Name}"
+      java_addEqualsOperation!(ret, callSuperEquals)
+      java_addHashCodeOperation!(ret)
+    end
+    return nil
+  end
+  
+  #adds a equals method
+  def java_addEqualsOperation!(attributesInSignature, callSuperEquals)
+    me=self.umlx_createAndAddOperation(self.rdf_uri+"_equals")
+    me.uml_name="equals"
+    #      me.uml_class=self
+    me.uml_visibility=Cuml_VisibilityKind::Public
+    rme=me.umlx_createAndAddReturnParameter("#{me.rdf_uri}_ret")
+    rme.uml_type=umlx_getOrCreateDataType("boolean")
+    rpe=me.umlx_createAndAddParameter("#{me.rdf_uri}_par", "o")
+    rpe.uml_type=umlx_getOrCreateClass("Object")
+    me.java_annotation_add("@Override")
+    meCode = <<CODE
+  if(this == o) {
+      return true;
+  }
+  if(o==null || !(o instanceof #{self.java_Name})) {
+      return false;
+  }
+CODE
+    if callSuperEquals
+    meCode << <<CODE
+  if !super.equals(o) {
+      return false;  
+  }
+CODE
+  else
+    meCode << "// do not use super.equals()\n"
+  end
+  meCode << <<CODE
+  final #{self.java_Name} _o = (#{self.java_Name}) o;
+CODE
+  attributesInSignature.each { |a|
+    meCode << <<CODE
+  if (#{a.java_Name} != null ?
+        !#{a.java_Name}.equals(_o.#{a.java_Name}) :
+        _o.#{a.java_Name} != null) {
+        return false;
+  }
+CODE
+  }
+  meCode << <<CODE
+  return true;
+CODE
+  me.java_code = meCode
+  return me
+end
+
+#adds a hash method
+def java_addHashCodeOperation!(attributesInSignature)
+  me=self.umlx_createAndAddOperation(self.rdf_uri+"_hash")
+  me.uml_name="hashCode"
+  me.uml_class=self
+  me.uml_visibility=Cuml_VisibilityKind::Public
+  rme=me.umlx_createAndAddReturnParameter("#{me.rdf_uri}_ret")
+  rme.uml_type=umlx_getOrCreateDataType("int")
+  me.java_annotation_add("@Override")
+  meCode = <<CODE
+  final int prime = 31;
+  int result = 1;
+CODE
+  attributesInSignature.each { |a|
+    meCode << <<CODE
+  result = prime * result + ((#{a.java_Name} == null) ? 0 : #{a.java_Name}.hashCode());
+CODE
+  }
+  meCode << <<CODE
+  return result;
+CODE
+  me.java_code = meCode
+  return me 
+end
+end

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

@@ -0,0 +1,95 @@
+# Scripting model enhancements.
+# Used in Groovy integration.
+#
+
+module Muml_Operation
+  # returns true if element is marked as scripted.
+  def umlx_isScripted?
+    return umlx_hasStereotype?("Script")
+  end
+end
+
+module Mrdf_Repository
+
+  # Retrieve an enumeration that will contain a list of script methods
+  def umlx_getScriptMethodEnumeration
+    return umlx_reserved_model.umlx_getOrCreateEnumeration("xmda.scripting.ScriptMethodInventory",Muml_Classifier::UMLX_SEARCH_EVERY_MODEL)
+  end
+
+  # populate script method inventory (which is stored as a java enum.)
+  def umlx_populateScriptedMethodEnumeration
+#    umlx_generateStaticSecurityRoleEnum
+    e=umlx_getScriptMethodEnumeration
+
+    #populate inventory
+    uml_Class_all.each {|c|
+      next unless c.umlx_businessMethod?
+      next if c.kind_of?(Muml_Interface)
+      cn="#{c.java_qualifiedName}.class"
+      c.uml_ownedOperation.each  {|op|
+        next unless op.umlx_businessMethod?
+	next unless op.umlx_isScripted?
+        #operation was generated from an interface
+        next if (!op.umlx_redefinesMethod.empty?) && (!op.umlx_redefinesMethod_one.umlx_owner_one.kind_of?(Muml_Interface))
+        lit=e.umlx_createAndAddLiteral("#{op.umlx_owner_one.java_qualifiedName}_#{op.java_Name}")
+        lit.java_initParameterValue_add(cn)
+        lit.java_initParameterValue_add(%{"#{op.java_Name}"})
+      }
+    }
+
+    cc=umlx_reserved_model.umlx_getOrCreateClass("java.lang.Classxx")
+    cc.uml_name="Class<?>"
+    cc.java_isGeneric=RDF_TRUE
+
+    str=e.umlx_owner_one.umlx_dataType_string
+    # add constructor
+    c=e.umlx_createAndAddOperation("#{c}.constructor","constructor")
+    c.uml_appliedStereotype_add(e.umlx_getOrCreateStereotype("Create"))
+    c.uml_visibility=::Cuml_VisibilityKind::Private
+    p1=c.umlx_createAndAddParameter("#{c.uri}_p1","_ownerClass")
+    p1.uml_type=cc
+    p2=c.umlx_createAndAddParameter("#{c.uri}_p2","_operationName")
+    p2.uml_type=str
+    c.java_code="ownerClass=_ownerClass;\noperationName=_operationName;"
+
+    #add attributes
+    a1=e.umlx_createAndAddProperty("#{e}_a1","ownerClass")
+    a1.uml_type=cc
+    a2=e.umlx_createAndAddProperty("#{e}_a2","operationName")
+    a2.uml_type=str
+
+    #add finder
+    f=e.umlx_createAndAddOperation("#{e.uri}_find","find")
+    f.uml_isStatic=RDF_TRUE
+    a1=f.umlx_createAndAddParameter("#{e}_a1","ownerClass")
+    a1.uml_type=cc
+    a2=f.umlx_createAndAddParameter("#{e}_a2","operationName")
+    a2.uml_type=str
+    a3=f.umlx_createAndAddReturnParameter("#{e}_ret","enum")
+    a3.uml_type=e
+    f.java_code=<<END
+//TODO !!!!!!!!!!!
+return null ; //#{e.java_Name}
+END
+
+  end
+
+  
+  #Java annotation used to mark a Secured method or field.
+  JAVA_SCRIPT_ANNOTATION="@xmda.scripting.aop.Script"
+   
+  # process element marked as secured
+  def umlx_processScriptedElements
+    
+    uml_Class_all.each {|c|
+      #sec=false
+      next if c.kind_of?(Muml_Interface) || c.kind_of?(Muml_Enumeration)
+      c.uml_ownedOperation.each {|o|
+        next unless o.umlx_isScripted? 
+        o.java_annotation_add(JAVA_SCRIPT_ANNOTATION)
+        #sec=true
+      } 
+    }
+  end
+  
+end