ontomde-java 2.0.0

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

@@ -0,0 +1,28 @@
+
+class Crdfs_Class
+
+	# UML metaclass to java class mapping.
+        # 
+	#Example:
+	# An UML metaclass class maps to a java.lang.Class java class.
+	#Note:
+	#  feature introduced for opencrx.
+	JAVA_METACLASS_MAPPING={
+		"uml_Class" => "java.lang.Class"
+		}
+
+	# returns the java class name for this meta-class.
+        # 
+	#Example:
+	#
+	#Note:
+	# added for openmdx which uses attributes of type "metaclass-class".
+	def java_qualifiedName
+		qn=JAVA_METACLASS_MAPPING[rdf_uri]
+		return qn unless qn.nil?
+		msg="unknown java_qualifiedName for meta-class #{rdf_uri}"
+		return "int /*TODO: #{msg} */"
+	end
+
+end
+

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

@@ -0,0 +1,144 @@
+#
+# This file is about generating forms associated to business method.
+# For example, if a class C has a method doThis with parameter p1 and p2,
+# a class doThisMPC would be generated with properties p1 and p2.
+# This class could then be used for creating a form that would contain
+# data for calling doThis method.
+
+
+module Muml_Classifier
+  # name of property which stores the object whose business method will be invoked.
+  STRUTS_APPLY_TO_PARAM="applyTo"
+  # name of bean property which stores the object whose business method will be invoked.
+  STRUTS_APPLY_TO_PROP="ApplyTo"
+end
+
+module Muml_Operation
+  # link to a form generated from this operation parameters.
+  rdf_safe_attr_reader_many :struts_bizOperationReverse
+end
+
+module Muml_Parameter
+  # the method parameter
+  rdf_safe_attr_reader_many :struts_sourceParameter
+end
+
+
+module Mrdf_Repository
+  # generates for every business operation in repository.
+  def struts_addAllOperationAggregateParameterClass!
+    return unless context[:withGenerateMethodForm]
+
+    uml_Class_all.each {|c|
+      #exclude classes explicitely set to false
+      next if (!c.umlx_businessMethod.empty?) && (!c.umlx_businessMethod?)
+      c.uml_ownedOperation.each {|biz|
+        #next if c.java_isATestFile?
+        next unless biz.kind_of?(Muml_Operation)
+        next unless biz.umlx_businessMethod?
+        next if biz.umlx_isConstructor?
+        next if biz.uml_visibility_one.isPrivate?
+        next if biz.uml_visibility_one.isProtected?
+        next if biz.uml_visibility_one.isPackage?
+        next if biz.uml_isStatic?
+        #c=biz.umlx_owner_one
+
+        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
+        next unless c.kind_of?(Muml_Class)
+
+        p=p.umlx_getOrCreatePackage(context[:classMethodSubDir,"methods"],p)
+        #BUG:biz_uri ne suffisait pas car si 2 classes immplémnetaient 2 fois une méthode d'une classe abstraite
+        #la classe crée avait les 2 mêmes uri et donc était zappé par la suite(notamment le java_transform
+        mpc=p.umlx_createAndAddClass(c.rdf_uri+biz.rdf_uri+"_mpc2");
+        mpc.umlx_businessMethod=RDF_TRUE
+        mpc.struts_addAllOperationAggregateParameterClass!(biz)
+        mpc.db_isTransient=RDF_TRUE
+        mpc.java_addTenantField!
+
+        m=mpc.umlx_createAndAddOperation(mpc.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=mpc
+
+        
+      
+      }}
+  end
+end
+module Muml_Classifier
+  # source business operation from which this class was generated.
+  rdf_safe_attr_reader_many :struts_bizOperation
+
+
+  STRUTS_RESULT_PARAM_NAME="_result"
+  # Creates a class for every business method holding every parameters
+  def struts_addAllOperationAggregateParameterClass!(biz)
+    mpc=self
+    mpc.struts_bizOperation=biz
+    biz.struts_bizOperationReverse_add(mpc)
+    #biz.struts_bizForm=mpc
+    mpc.uml_name="#{biz.umlx_owner_one.java_Name}#{biz.java_Name}MPC"
+    (biz.uml_ownedParameter+biz.uml_returnResult).each { |param|
+      #next if param.uml_direction_one.isReturn?
+      mpcp=mpc.umlx_createAndAddProperty(mpc.rdf_uri+"_mpc3")
+      param.umlx_copyToAttributeProperty(mpcp)
+      mpcp.uml_name= param.uml_direction_one.isReturn? ? STRUTS_RESULT_PARAM_NAME : param.uml_name
+    }
+    mpc.struts_addApplyToParameter!(biz)
+    mpc.struts_addProceed!(biz)
+    #mpc.apaCom_addLogger!
+  end
+
+  # generates an apply to parameter 
+  def struts_addApplyToParameter!(biz)
+    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
+
+  # generates a proceed operation.
+  def struts_addProceed!(biz)
+    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/java/security.rb

@@ -0,0 +1,260 @@
+# Authentification and security model enhancements.
+# Used in acegi integration.
+#
+
+module Muml_Property
+  # returns true if element is marked as secured.
+  def umlx_isSecured?
+    return umlx_hasStereotype?("Secured")
+  end
+end
+module Muml_Operation
+  # returns true if element is marked as secured.
+  def umlx_isSecured?
+    return umlx_hasStereotype?("Secured")
+  end
+end
+
+module Mrdf_Repository
+
+  # Retrieve an enumeration that will contain a list of secured methods
+  def umlx_getSecuredMethodEnumeration
+    return umlx_reserved_model.umlx_getOrCreateEnumeration("xmda.security.SecuredMethodInventory",Muml_Classifier::UMLX_SEARCH_EVERY_MODEL)
+  end
+
+  # populate secured method inventory (which is stored as a java enum.)
+  def umlx_populateSecuredMethodEnumeration
+    umlx_generateStaticSecurityRoleEnum
+    e=umlx_getSecuredMethodEnumeration
+
+    #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_isSecured?
+        #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_GLOBAL_ACCESS_CONTROL_ENUM="xmda .security.StaticSecurityRole"
+  # Enumerated containing the list of all access control criteria
+  JAVA_GLOBAL_ACCESS_CONTROL_ENUM="xmda.security.GlobalComputedAccessControlCriteria"
+  JAVA_GLOBAL_ACCESS_CONTROL_ENUM_COMMENT=<<ENDHELP
+This enum contains a list of all computed access control criteria.
+
+Generic examples of access control:
+* userIsManagerForThisObject
+* userOwnsThisObject
+* userIsOnDuty
+
+AccessControl criteria are computed in the context of one class instance of the model and one user. (ex: User Martin accessing contract number 3003).
+
+Some criteria migth not need to know what object is beeing accessed (example: userIsOnDuty). Some other will need to know what object is access (Is martin a manager for contract 42000 ?, Does Martin owns product number 13239 ?)
+
+This list is defined at design time because these rules criteria are implemented usign an algorithm (model query, date computation, ...) that require some coding and optimisation at developpement time. It is however possible to add RESERVED elements for future extension (RESERVED1, RESERVED2, ...).
+ENDHELP
+
+
+  # Model may contain several enumeration of roles stereotypes staticSecurityRole
+  # For implementation use, an enumeration containing every roles is generated.
+  # Role container name could be appended to role name but it is not because it
+  # would make code refactoring more complex.
+  # As a consequence, role name should be unique application wide.
+  def  umlx_generateStaticSecurityRoleEnum
+    e=umlx_reserved_model.umlx_getOrCreateEnumeration(JAVA_GLOBAL_ACCESS_CONTROL_ENUM,Muml_Classifier::UMLX_SEARCH_EVERY_MODEL)
+    e.umlx_createAndAddComment("#{e.rdf_uri}_comment",JAVA_GLOBAL_ACCESS_CONTROL_ENUM_COMMENT) if e.uml_ownedComment.empty?
+
+    self.each_value { |v|
+      next unless v.kind_of?(Muml_Enumeration)
+      #next unless v.umlx_hasStereotype?("staticSecurityRole")
+      next unless v.umlx_hasStereotype?("ComputedAccessControlCriteria")
+      v.uml_ownedLiteral.each {|c|
+        #role name should be unique
+        e.umlx_createAndAddLiteral(c.to_s)
+      }
+    }
+  end
+
+  # Retrieve an enumeration that will contain a list of secured property 
+  def umlx_getSecuredPropertyEnumeration
+    return umlx_reserved_model.umlx_getOrCreateEnumeration("xmda.security.SecuredPropertyInventory",Muml_Classifier::UMLX_SEARCH_EVERY_MODEL)
+  end
+
+  # Populate secured property inventory (which is stored as a java enum)
+  def umlx_populateSecuredPropertyEnumeration
+    #umlx_generateStaticSecurityRoleEnum
+    e=umlx_getSecuredPropertyEnumeration
+
+    #populate inventory
+    uml_Class_all.each {|c|
+      next unless c.umlx_businessMethod?
+      
+      #Hack: transient operation 
+      #next if c.db_isTransient?
+      
+      
+      next if c.kind_of?(Muml_Interface)
+      cn="#{c.java_qualifiedName}.class"
+      c.uml_ownedAttribute.each  {|op|
+        #next unless op.umlx_businessMethod?
+        #operation was generated from an interface
+        #next if (!op.umlx_redefinesProperty.empty?) && (!op.umlx_redefinesProperty_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}"})
+        lit.java_initParameterValue_add(op.umlx_isSecured?)
+      }
+    }
+
+
+    #Classxx is on purpose
+    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
+    bol=e.umlx_owner_one.umlx_dataType_boolean
+    # 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","_propertyName")
+    p2.uml_type=str
+    p3=c.umlx_createAndAddParameter("#{c.uri}_p3","_isSecured")
+    p3.uml_type=bol
+    c.java_code="ownerClass=_ownerClass;\npropertyName=_propertyName;\nisSecured=_isSecured;"
+
+    #add attributes
+    a1=e.umlx_createAndAddProperty("#{e}_a1","ownerClass")
+    a1.uml_type=cc
+    a2=e.umlx_createAndAddProperty("#{e}_a2","propertyName")
+    a2.uml_type=str
+    a3=e.umlx_createAndAddProperty("#{e}_a2","isSecured")
+    a3.uml_type=bol
+
+
+    #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","propertyName")
+    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_SECURE_ANNOTATION="@xmda.security.Secure"
+   
+  # process element marked as secured
+  def umlx_processSecuredElements
+    e=umlx_reserved_model.umlx_getOrCreateInterface("org.springframework.security.userdetails.UserDetails")
+    
+    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_isSecured? 
+        o.java_annotation_add(JAVA_SECURE_ANNOTATION)
+        #sec=true
+      } 
+      c.uml_ownedAttribute.each { |a|
+        next unless a.umlx_isSecured?
+        a.java_annotation_add(JAVA_SECURE_ANNOTATION)
+        #sec=true
+      }
+      c.umlx_addGetStaticRoleOperation! #if sec
+    }
+  end
+  
+end
+module Muml_Class
+  
+  # method comment that will be generated as javadoc
+  JAVA_GETSTATIC_ROLE_COMMENT=<<ENDHELP 
+This method returns a set of "static roles" that *may* *be* granted to the user based on database informations. 
+
+When a "security role" (defined at runtime) is bounded(linked) to a "static role" (defined at compile time), 
+users must 
+- be granted the security role 
+- and the bounded "static role" must be included in the set of role returned by this method.
+ENDHELP
+  
+  #method default implementation
+  JAVA_GETSTATIC_ROLE_CODE=<<ENDROLECODE
+//return empty list (every static role are denied)
+return new java.util.HashSet<#{Mrdf_Repository::JAVA_GLOBAL_ACCESS_CONTROL_ENUM}>();
+ENDROLECODE
+  
+  # Adds methods which returns computed grants to user.
+  # This methods returns an list of granted rights (which are stored as java enums)
+  # 
+  # Example:
+  # * public List<SecurityRole> getComputedAccessControlGrant(org.acegi.security.UserDetails userName
+  def umlx_addGetStaticRoleOperation!
+    m=self.umlx_createAndAddOperation("#{rdf_uri}_getComputedAccessControlGrant","getComputedAccessControlGrant")
+  
+    r=m.umlx_createAndAddReturnParameter("#{m.rdf_uri}_return")
+    r.uml_type=umlx_reserved_model.umlx_getOrCreateEnumeration(Mrdf_Repository::JAVA_GLOBAL_ACCESS_CONTROL_ENUM,Muml_Classifier::UMLX_SEARCH_EVERY_MODEL)
+    r.uml_upperValue=umlx_literal(-1)
+    r.umlx_createAndAddComment("#{r.rdf_uri}_c1",JAVA_GETSTATIC_ROLE_COMMENT)
+ 
+    p=m.umlx_createAndAddParameter("#{m.rdf_uri}_p1","user")
+    p.uml_type=umlx_reserved_model.umlx_getOrCreateEnumeration("org.springframework.security.userdetails.UserDetails",Muml_Classifier::UMLX_SEARCH_EVERY_MODEL)
+    
+    m.java_code=JAVA_GETSTATIC_ROLE_CODE
+  end
+end
+

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

@@ -0,0 +1,415 @@
+#
+# This application reads a uml2 state machine 
+# and generates a graphviz graph from it.
+#
+# This is a basic generator for State Machine Generator
+# cf: http://smc.sourceforge.net/SmcManSec2.htm
+#
+
+
+require 'ontomde-uml2'
+
+
+
+module Mrdf_Repository
+  def java_getClassWithQualifiedName(qname)
+    uml_Class_all.each { |f|
+      return f if f.java_qualifiedName.to_s.casecmp(qname)==0
+    }
+    puts "not found #{qname}"
+    #exit 1
+    return nil
+  end
+end
+
+module Muml_Operation
+  #Indique si c'est une m�thode g�r�e par la machine � �tat
+  attr_accessor :java_isFsmOperation
+end
+
+module Muml_Classifier
+
+  #FSMContext of the StateMachine
+  rdf_safe_attr_reader_many :java_FSMContext
+  #State of the StateMachine
+  rdf_safe_attr_reader_many :java_FSMState
+  
+  def java_addStateManagement
+    
+      fsmState = self.java_FSMState_one
+      fsmContext = self.java_FSMContext_one
+      
+      #TODO Corriger le bug avec JPA qui emp�che de rajouter cette interface
+#      typecomp=umlx_getOrCreateInterface("xmda.fsm.FsmComponent<#{fsmContext.java_qualifiedName}>")
+#      typecomp.java_isGeneric=RDF_TRUE
+#      umlx_createAndAddImplementation(typecomp)
+      
+      fsm=umlx_createAndAddProperty(rdf_uri+"_fsm", "fsmCtx")
+      fsm.uml_type=java_FSMContext_one
+      fsm.db_isTransient=RDF_TRUE
+      fsm.uml_visibility=::Cuml_VisibilityKind::Private
+      fsm.java_annotation_add("@javax.persistence.Transient")
+      get=java_addGlobalGetter!(fsm)
+      get.java_code=<<CODE
+      if (fsmCtx==null || getPersistedState().compareToIgnoreCase(fsmCtx.getState().getName()) != 0) {
+        saasAdministration.fsm.MDAaasApplicationInstanceState currentState = saasAdministration.fsm.MDAaasApplicationInstanceState.findStateByName(getPersistedState());
+        fsmCtx = new saasAdministration.fsm.MDAaasApplicationInstanceFSMContext(this, currentState);
+      }
+      return fsmCtx;
+
+CODE
+  
+      persState=umlx_createAndAddProperty(rdf_uri+"_state", "persistedState")
+      persState.uml_type=umlx_dataType_string
+      persState.uml_visibility=::Cuml_VisibilityKind::Private
+      java_addGlobalSetter!(persState)
+      getState=java_addGlobalGetter!(persState)
+      getState.java_code=<<CODE
+      if (persistedState==null || persistedState.length()<=0) {
+          fsmCtx = new saasAdministration.fsm.MDAaasApplicationInstanceFSMContext(this);
+          setPersistedState(fsmCtx.getState().getName());
+      }
+      return persistedState;
+CODE
+  
+    
+       # Gestion de la synchronisation du champ persistedState et fsmCtx transient   
+       ent=umlx_getOrCreateInterface("java.beans.PropertyChangeListener")
+       umlx_createAndAddImplementation(ent)
+       m=umlx_createAndAddOperation(rdf_uri+"_prop","propertyChange")
+       m.uml_visibility=Cuml_VisibilityKind::Public
+       arg1=m.umlx_createAndAddParameter(m.rdf_uri+"_evt","evt")
+       arg1.uml_direction=Cuml_ParameterDirectionKind::In
+       arg1.uml_upperValue=umlx_literal(1)
+       arg1.uml_lowerValue=umlx_literal(1)    
+       arg1.uml_type=umlx_getOrCreateInterface("java.beans.PropertyChangeEvent")
+       m.java_code=<<CODE
+        #{fsmState.java_qualifiedName} newState = (#{fsmState.java_qualifiedName}) evt.getNewValue();
+        setPersistedState(newState.getName());
+CODE
+
+  end
+
+  def findOperationByName(methodName)
+    uml_ownedOperation.each { |o|
+      return o if methodName == "#{o.java_Name}"
+    }
+    return nil    
+  end
+  #t transition
+  def java_getOrCreateOperationForTransition(t)
+    opForT = findOperationByName("#{t.uml_name}")
+    if opForT.nil?
+         opForT=umlx_createAndAddOperation(rdf_uri+"_#{t.uml_name}","#{t.uml_name}")
+         opForT.uml_visibility=Cuml_VisibilityKind::Public
+         opForT.umlx_businessMethod=RDF_TRUE
+    end
+    opForT.java_annotation_add("@xmda.fsm.StateMachineTransition")
+    opForT.java_isFsmOperation=true
+    opForT.java_code=<<CODE
+         getFsmCtx().#{opForT.java_Name}();
+CODE
+  end
+end
+module Muml_FinalState
+  def fsm_name
+    n=uml_name_one0
+    return n.nil? ? "Final" : n
+  end
+end
+module Muml_Pseudostate
+  #myClazz = classe qui est caract�ris� par la machine � �tat
+  def processVertex(myClazz)
+    # Calculer l'�tat initial et rajouter le constructeur de la classe contexte qui initialise � cet �tat
+    if self.uml_kind_one == ::Cuml_PseudostateKind::Initial
+      self.uml_outgoing.each { |t|
+         fsmState = myClazz.java_FSMState_one
+         fsmContext = myClazz.java_FSMContext_one
+         construct=fsmContext.umlx_createAndAddOperation(fsmState.rdf_uri+"_constructor","constructor")
+         construct.uml_appliedStereotype_add(fsmContext.umlx_getOrCreateStereotype("Create"))
+         construct.uml_visibility=Cuml_VisibilityKind::Public
+         arg1=construct.umlx_createAndAddParameter(construct.rdf_uri+"_owner","owner")
+         arg1.uml_direction=Cuml_ParameterDirectionKind::In
+         arg1.uml_upperValue=fsmState.umlx_literal(1)
+         arg1.uml_lowerValue=fsmState.umlx_literal(1)    
+         arg1.uml_type=myClazz
+         construct.java_code=<<CODE
+        this.owner = owner;
+        this.addStateChangeListener(owner);
+        setState(#{fsmState.java_qualifiedName}.#{t.uml_target_one.java_Name.downcase}state);
+        #{fsmState.java_qualifiedName}.#{t.uml_target_one.java_Name.downcase}state.Entry(this);
+CODE
+
+         construct2=fsmContext.umlx_createAndAddOperation(fsmState.rdf_uri+"_constructor2","constructor2")
+         construct2.uml_appliedStereotype_add(fsmContext.umlx_getOrCreateStereotype("Create"))
+         construct2.uml_visibility=Cuml_VisibilityKind::Public
+         arg3=construct2.umlx_createAndAddParameter(construct2.rdf_uri+"_owner","owner")
+         arg3.uml_direction=Cuml_ParameterDirectionKind::In
+         arg3.uml_upperValue=fsmState.umlx_literal(1)
+         arg3.uml_lowerValue=fsmState.umlx_literal(1)    
+         arg3.uml_type=myClazz
+         arg2=construct2.umlx_createAndAddParameter(construct2.rdf_uri+"_initState","initState")
+         arg2.uml_direction=Cuml_ParameterDirectionKind::In
+         arg2.uml_upperValue=fsmState.umlx_literal(1)
+         arg2.uml_lowerValue=fsmState.umlx_literal(1)    
+         arg2.uml_type=fsmState
+         construct2.java_code=<<CODE
+        this.owner = owner;
+        this.addStateChangeListener(owner);        
+        setState(initState);
+CODE
+      
+      }
+    else
+      raise Warning.new,"PseudState not managed except ::Cuml_PseudostateKind::Initial"
+    end
+  end
+  
+  def fsm_name
+    n=uml_name_one0
+    return n.nil? ? rdf_uri : n
+  end
+end
+module Muml_PseudostateKind
+end
+module Muml_Region
+end
+module Muml_Signal
+end
+module Muml_SignalTrigger
+end
+module Muml_State
+  def processVertex(myClazz)
+    # Generate the class for this state
+    p=myClazz.umlx_package
+    p=p.umlx_getOrCreatePackage("fsm",p)
+
+    fsmState = myClazz.java_FSMState_one
+    fsmContext = myClazz.java_FSMContext_one
+    
+    state=p.umlx_createAndAddClass(self.rdf_uri+"_State")
+    state.uml_name="#{self.java_Name}State"
+    state.db_isTransient=RDF_TRUE    
+    state.umlx_createAndAddGeneralization(fsmState)
+    construct=state.umlx_createAndAddOperation(state.rdf_uri+"_constructor","constructor")
+    construct.uml_appliedStereotype_add(state.umlx_getOrCreateStereotype("Create"))
+    construct.uml_visibility=Cuml_VisibilityKind::Public
+    construct.java_code=<<CODE
+          super("#{state.java_qualifiedName}");
+CODE
+
+    pconst=fsmState.umlx_createAndAddProperty(state.rdf_uri+"_Const", "#{state.java_Name.downcase}")
+    pconst.java_noAccessors="true"
+    pconst.uml_type=state
+    pconst.uml_visibility=Cuml_VisibilityKind::Public
+    pconst.uml_isStatic=RDF_TRUE
+    pconst.java_isFinal="true"
+    pconst.java_code=<<CODE
+    new #{state.java_qualifiedName}();
+CODE
+
+    # Ajouter les m�thodes � la super classe State et au State concern�
+    # Ajouter ou retrouver la m�thode de la classe m�re
+    self.uml_outgoing.each { |t|   
+          m = fsmState.findOperationByName("#{t.uml_name}")
+          # Faire une seule fois (cas ou on a plusieurs transitions de m�me nom)
+          if m.nil?
+              m=fsmState.umlx_createAndAddOperation(fsmState.rdf_uri+"_#{t.uml_name}","#{t.uml_name}")
+              m.uml_visibility=Cuml_VisibilityKind::Public
+              em=m.umlx_createAndAddParameter(m.rdf_uri+"_ctx","ctx")
+              em.uml_type=fsmContext
+              em.uml_direction=Cuml_ParameterDirectionKind::In
+              em.uml_upperValue=fsmState.umlx_literal(1)
+              em.uml_lowerValue=fsmState.umlx_literal(1)
+              m.java_code=<<CODE
+          defaultBehavior(ctx);
+CODE
+
+              m3=fsmContext.umlx_createAndAddOperation(fsmContext.rdf_uri+"_#{t.uml_name}","#{t.uml_name}")
+              m3.uml_visibility=Cuml_VisibilityKind::Public
+              m3.java_code=<<CODE
+            _transition = "#{t.uml_name}";
+            getState().#{t.uml_name}(this);
+            _transition = null;
+CODE
+              
+             myClazz.java_getOrCreateOperationForTransition(t) 
+
+          end
+          m2=state.umlx_createAndAddOperation(state.rdf_uri+"_#{t.uml_name}","#{t.uml_name}")
+          m2.uml_visibility=Cuml_VisibilityKind::Public
+          em2=m2.umlx_createAndAddParameter(m2.rdf_uri+"_ctx","ctx")
+          em2.uml_type=fsmContext
+          em2.uml_direction=Cuml_ParameterDirectionKind::In
+          em2.uml_upperValue=state.umlx_literal(1)
+          em2.uml_lowerValue=state.umlx_literal(1)
+          m2.java_code=<<CODE
+          (ctx.getState()).Exit(ctx);
+          ctx.setState(#{fsmState.java_Name}.#{t.uml_target_one.java_Name.downcase}state);
+          (ctx.getState()).Entry(ctx);
+CODE
+          
+    }
+    
+  end
+  def fsm_name
+    n=uml_name_one0
+    return n.nil? ? rdf_uri : n
+  end
+end
+module Muml_StateMachine
+  def processStateMachine
+    puts "Processing StateMachine #{self.java_qualifiedName}"
+
+    mrdf=context[:umlModel,self.rdf_Repository]
+    muml=mrdf.umlx_reserved_model
+    myClazz=mrdf.java_getClassWithQualifiedName("#{self.java_qualifiedName}")
+    raise Warning.new,"No Class with the same bame as ths StateMachine #{self.java_qualifiedName} !!!!" if myClazz.nil?
+    p=myClazz.umlx_package
+    p=p.umlx_getOrCreatePackage("fsm",p)
+    
+    fsmCtx=umlx_getOrCreateClass("xmda.fsm.FSMContext")
+    fsmCtx.umlx_external="true"
+    fsmState=umlx_getOrCreateClass("xmda.fsm.State")
+    fsmState.umlx_external="true"
+    
+    appFsmState=p.umlx_createAndAddClass(myClazz.rdf_uri+"_FSMState")
+    appFsmState.uml_name="#{myClazz.java_Name}State"
+    appFsmState.db_isTransient=RDF_TRUE
+    appFsmState.umlx_createAndAddGeneralization(fsmState)
+    myClazz.java_FSMState = appFsmState
+    construct=appFsmState.umlx_createAndAddOperation(fsmCtx.rdf_uri+"_constructor","constructor")
+    construct.uml_appliedStereotype_add(appFsmState.umlx_getOrCreateStereotype("Create"))
+    arg1=construct.umlx_createAndAddParameter(construct.rdf_uri+"_name","name")
+    arg1.uml_direction=Cuml_ParameterDirectionKind::In
+    arg1.uml_upperValue=umlx_literal(1)
+    arg1.uml_lowerValue=umlx_literal(1)    
+    arg1.uml_type=umlx_dataType_string
+    construct.uml_visibility=Cuml_VisibilityKind::Public
+    construct.java_code=<<CODE
+          super(name);
+          allStates.put(getName(), this);
+CODE
+    pconst=appFsmState.umlx_createAndAddProperty(appFsmState.rdf_uri+"_AllConst", "allStates")
+    pconst.java_noAccessors="true"
+    typeconst=appFsmState.umlx_getOrCreateInterface("java.util.HashMap<String, #{appFsmState.java_qualifiedName}>")
+    typeconst.java_isGeneric=RDF_TRUE
+    pconst.uml_type=typeconst
+    pconst.uml_visibility=Cuml_VisibilityKind::Private
+    pconst.uml_isStatic=RDF_TRUE
+    pconst.java_isFinal="true"
+    pconst.java_code=<<CODE
+    new #{typeconst.java_qualifiedName}();
+CODE
+    mfind=appFsmState.umlx_createAndAddOperation(appFsmState.rdf_uri+"_find","findStateByName")
+    mfind.uml_visibility=Cuml_VisibilityKind::Public
+    mfind.uml_isStatic=RDF_TRUE
+    argfind=mfind.umlx_createAndAddParameter(mfind.rdf_uri+"_name","name")
+    argfind.uml_direction=Cuml_ParameterDirectionKind::In
+    argfind.uml_upperValue=umlx_literal(1)
+    argfind.uml_lowerValue=umlx_literal(1)    
+    argfind.uml_type=umlx_dataType_string
+    rp=mfind.umlx_createAndAddParameter(mfind.rdf_uri+"_ret_param","return")
+    rp.uml_direction=Cuml_ParameterDirectionKind::Return
+    rp.uml_upperValue=umlx_literal(1)
+    rp.uml_lowerValue=umlx_literal(1)    
+    rp.uml_type=appFsmState
+    mfind.java_code=<<CODE
+         return allStates.get(name);
+CODE
+
+     
+    appFsmCtx=p.umlx_createAndAddClass(myClazz.rdf_uri+"_FSMContext")
+    appFsmCtx.uml_name="#{myClazz.java_Name}FSMContext"
+    appFsmCtx.db_isTransient=RDF_TRUE
+    appFsmCtx.umlx_createAndAddGeneralization(fsmCtx)
+    myClazz.java_FSMContext = appFsmCtx
+    m=appFsmCtx.umlx_createAndAddOperation(fsmCtx.rdf_uri+"_ret","getState")
+    m.uml_visibility=Cuml_VisibilityKind::Public
+    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)    
+    rp.uml_type=appFsmState
+          m.java_code=<<CODE
+          return (#{appFsmState.java_qualifiedName})_state;
+CODE
+    p2=appFsmCtx.umlx_createAndAddProperty(fsmState.rdf_uri+"_prop_owner", "owner")
+    p2.uml_type=myClazz
+    p2.uml_visibility=::Cuml_VisibilityKind::Private
+    appFsmCtx.java_addGlobalGetter!(p2)
+    appFsmCtx.java_addGlobalSetter!(p2)
+
+    uml_region.each { |reg|
+      reg.uml_subvertex.each { |v|
+         v.processVertex(myClazz)
+      }
+    }
+
+    # Rajouter le contexte dans la classe
+    myClazz.java_addStateManagement
+    #Chercher ou la g�n�rer pour chaque transition
+
+
+
+
+#    self.mtk_writeSession("output/sm_#{self}.fsm") {
+#      write <<END
+#%{
+#// This file is a State Machine Compiler class 
+#// http://smc.sourceforge.net
+#//
+#%}
+#// This FSM works for the Task class only and only the Task 
+#// class may instantiate it.
+#%class
+#Task
+#%package TODOcom.acme.supercron
+#%access package
+#%start xxxxx
+#%map yyyy
+#%%
+#END
+#      uml_region.each { |reg|
+#	reg.uml_subvertex.each { |v|
+#	  write("//state type=#{v.class.name} name=#{v.uml_name} \n")
+#	  write("#{v.fsm_name}\n")
+#	  write("{\n")
+#	  v.uml_outgoing.each { |tr|
+#	    write(" "*2+"#{tr.uml_name}() //Transition\n")
+#	    tr.uml_guard.each {|guard|
+#	      write(" "*4+"[#{guard.uml_specification_one.uml_body}] // Guard condition\n")
+#	    }
+#	    write(" "*4+"#{tr.uml_target_one==tr.uml_source_one ? "nil" : tr.uml_target_one.fsm_name} //End State\n")
+#	    write(" "*4+"{\n")
+#	    write(" "*6+"//Action code goes here\n")
+#	    tr.uml_trigger.each {|trig|
+#	      write(" "*8+"#{trig.uml_name}; // call #{trig.class.name}\n")
+#            }
+#	    write(" "*4+"}\n")
+#          }
+#	  write("}\n")
+#	  write("\n")
+#	  
+#        }	
+#      }
+#      write("}\n")
+#    }
+  end
+end
+module Muml_Stereotype
+end
+module Muml_Transition
+end
+module Muml_TransitionKind
+end
+module Muml_VisibilityKind
+end
+module Mrdf_Repository
+  def java_addStateMachine!()
+    each_value { |sm|
+      next unless sm.kind_of?(Muml_StateMachine)
+      sm.processStateMachine
+    }
+  end
+end