[Pymerase-cvs-commit] smw/smw/mmgen/UML14 01-02-15.xml,NONE,1.1 01-02-16.dtd,NONE,1.1 01-02-23.mdl,NONE,1.1 UML14actions.py,NONE,1.1 UML14template.py,NONE,1.1

[<de...@us...>]

Update of /cvsroot/pymerase/smw/smw/mmgen/UML14
In directory sc8-pr-cvs1:/tmp/cvs-serv32238/smw/mmgen/UML14

Added Files:
	01-02-15.xml 01-02-16.dtd 01-02-23.mdl UML14actions.py 
	UML14template.py 
Log Message:
Imported version of SMW downloaded on 2003 Apr 14

--- NEW FILE: 01-02-15.xml ---
<?xml version="1.0" encoding="UTF-8" ?>
<!-- <!DOCTYPE XMI SYSTEM 'Model.dtd'> -->
<XMI xmi.version='1.1' xmlns:Model='omg.org/mof.Model/1.3'>
  <XMI.header>
    <XMI.model xmi.name='UML' xmi.version='1.4'/>
    <XMI.metamodel xmi.name='Model' xmi.version='1.3'/>
  </XMI.header>
  <XMI.content>
    <Model:Package xmi.id='a0' name='UML' annotation='' isRoot='false' isLeaf='false' isAbstract='false' visibility='public_vis'>
      <Model:Namespace.contents>
        <Model:Tag xmi.id='a1' name='org.omg.mof.idl_prefix=org.omg' annotation='' tagId='org.omg.mof.idl_prefix' elements='a0'>
          <Model:Tag.values>
            <XMI.any xmi.type='string'>org.omg</XMI.any>
          </Model:Tag.values>
        </Model:Tag>
        <Model:Tag xmi.id='a2' name='org.omg.xmi.namespace=UML' annotation='' tagId='org.omg.xmi.namespace' elements='a0'>
          <Model:Tag.values>
            <XMI.any xmi.type='string'>UML</XMI.any>
          </Model:Tag.values>
[...5186 lines suppressed...]
                <XMI.field>1</XMI.field> <!-- lower -->
                <XMI.field>1</XMI.field> <!-- upper -->
                <XMI.field>false</XMI.field> <!-- is_ordered -->
                <XMI.field>false</XMI.field> <!-- is_unique -->
              </Model:AssociationEnd.multiplicity>
            </Model:AssociationEnd>
            <Model:AssociationEnd xmi.id='a798' name='elementImport' annotation='' isNavigable='true' aggregation='none' isChangeable='true' type='a797'>
              <Model:AssociationEnd.multiplicity>
                <XMI.field>0</XMI.field> <!-- lower -->
                <XMI.field>-1</XMI.field> <!-- upper -->
                <XMI.field>false</XMI.field> <!-- is_ordered -->
                <XMI.field>true</XMI.field> <!-- is_unique -->
              </Model:AssociationEnd.multiplicity>
            </Model:AssociationEnd>
          </Model:Namespace.contents>
        </Model:Association>
      </Model:Namespace.contents>
    </Model:Package>
  </XMI.content>
</XMI>

--- NEW FILE: 01-02-16.dtd ---
<!-- _______________________________________________________________ -->
<!--                                                                 -->
<!-- XMI is the top-level XML element for XMI transfer text          -->
<!-- _______________________________________________________________ -->

<!ELEMENT XMI (XMI.header?, XMI.content?, XMI.difference*,
               XMI.extensions*)>
<!ATTLIST XMI
            xmi.version CDATA #FIXED "1.1"
            timestamp CDATA #IMPLIED
            verified (true|false) #IMPLIED>

<!-- _______________________________________________________________ -->
<!--                                                                 -->
<!-- XMI.header contains documentation and identifies the model,     -->
<!-- metamodel, and metametamodel                                    -->
<!-- _______________________________________________________________ -->

<!ELEMENT XMI.header (XMI.documentation?, XMI.model*, XMI.metamodel*,
[...1684 lines suppressed...]
<!ELEMENT UML:ElementImport.isSpecification EMPTY>
<!ATTLIST UML:ElementImport.isSpecification xmi.value (true|false) #REQUIRED>
<!ELEMENT UML:ElementImport.package (UML:Package)*>
<!ELEMENT UML:ElementImport.importedElement (UML:ModelElement)*>
<!ENTITY % UML:ElementImportFeatures 'XMI.extension |
   UML:ElementImport.visibility |
   UML:ElementImport.alias |
   UML:ElementImport.isSpecification |
   UML:ElementImport.package |
   UML:ElementImport.importedElement'>
<!ENTITY % UML:ElementImportAtts '%XMI.element.att; %XMI.link.att;
   visibility %UML:VisibilityKind; #IMPLIED
   alias CDATA #IMPLIED
   isSpecification (true|false) #IMPLIED
   package IDREFS #IMPLIED
   importedElement IDREFS #IMPLIED'>
<!ELEMENT UML:ElementImport (%UML:ElementImportFeatures;)*>
<!ATTLIST UML:ElementImport %UML:ElementImportAtts;>

<!-- ========= UML:UML ========= -->

--- NEW FILE: 01-02-23.mdl ---

(object Petal
    version    	44
    _written   	"Rose 7.0.9420.17"
    charSet    	0)

(object Design "Logical View"
    is_unit    	TRUE
    is_loaded  	TRUE
    quid       	"3A71E26E0182"
    defaults   	(object defaults
	rightMargin 	0.250000
	leftMargin 	0.250000
	topMargin  	0.250000
	bottomMargin 	0.500000
	pageOverlap 	0.250000
	clipIconLabels 	TRUE
	autoResize 	TRUE
	snapToGrid 	TRUE
[...36057 lines suppressed...]
			tool       	"XML_DTD"
			name       	"DefaultDeclType"
			value      	"")))
	    (object Attribute
		tool       	"XML_DTD"
		name       	"default__Module-Spec"
		value      	(list Attribute_Set
		    (object Attribute
			tool       	"XML_DTD"
			name       	"Assign All"
			value      	FALSE)
		    (object Attribute
			tool       	"XML_DTD"
			name       	"ComponentPath"
			value      	"")))
	    (object Attribute
		tool       	"XML_DTD"
		name       	"HiddenTool"
		value      	FALSE))
	quid       	"38431EDC01D9"))

--- NEW FILE: UML14actions.py ---
import string
from qt import *
    
def newMultiplicity(lower=1,upper=1):
    m=Multiplicity()
    m.range.insert(MultiplicityRange(lower=lower,upper=upper))
    return m

def newAssociation(classifier1,classifier2,name=None):
    if not name:
        name=''
    as=Association(name=name,namespace=classifier1.namespace)
    ae1=AssociationEnd(participant=classifier1,
                       association=as,
                       multiplicity=newMultiplicity(1,1),
                       isNavigable=1)
        
    ae2=AssociationEnd(participant=classifier2,
                       association=as,
                       multiplicity=newMultiplicity(1,1),
                       isNavigable=1)

    return as

def newAssociationRole(classifierrole1,classifierrole2,name=None):
    if not name:
        name='unnamed'
    baseAss=classifierrole1.base[0].association[0].association #FIXME
    asr=AssociationRole(base=baseAss,name=name,namespace=classifierrole1.namespace)
    aer1=AssociationEndRole(association=asr,
                            participant=classifierrole1,
                            base=baseAss.connection[0],
                            multiplicity=newMultiplicity(1,1),
                            isNavigable=1)
    aer2=AssociationEndRole(association=asr,
                            participant=classifierrole2,
                            base=baseAss.connection[1],
                            multiplicity=newMultiplicity(1,1),
                            isNavigable=1)

    return asr
def collectAssociations(clf,assoc=None):
    """Method for collecting all AssociationEnds from a classifier and all
    its superclasses.
    """
    if not assoc:
        assoc=[]
    assoc+=clf.association
    for g in clf.generalization:
        assoc+=g.parent.association
        if g.parent.generalization:
            return collectAssociations(g.parent,assoc)
    else:
        return assoc

def newLink(instance1,instance2,name=None):
    """Creates a new link between two instances, there must exist an
    association between the base classifiers (or superclasses of these)
    for the link to map onto, otherwise it will return None and no Link
    is created.
    returns the new Link
    """
    if not name:
        name='unnamed'
    baseAss=None

    assocs1=MMSet()
    assocs2=MMSet()

    assocs1=collectAssociations(instance1.classifier[0])
    assocs2=collectAssociations(instance2.classifier[0])
    for a in assocs1:
        for b in assocs2:
            if not a == b and a.association == b.association:
                baseAss=a.association
                break

    if not baseAss:
        return None
    
    link=Link(name=name,association=baseAss,namespace=instance1.namespace)

    if baseAss.connection[0].participant == instance1.classifier[0]:
        le1=LinkEnd(instance=instance1,link=link,
                    associationEnd=baseAss.connection[0])
        le2=LinkEnd(instance=instance2,link=link,
                    associationEnd=baseAss.connection[1])
    else:
        le1=LinkEnd(instance=instance1,link=link,
                    associationEnd=baseAss.connection[1])
        le2=LinkEnd(instance=instance2,link=link,
                    associationEnd=baseAss.connection[0])
    
    return link

def fromMultiplicityToString(multiplicity):
    """
    fromMultiplicityToString creates a string from a multiplicity instance that
    will be displayed in the editor, i.e. 2..7 .

    Example: 
      testlist='2..7'
      a=fromStringToMultiplicity(testlist)
      b=fromMultiplicityToString(a)
      assert('2..7'==b)
    """
    
    outString=""
   
    for i in multiplicity.range:
        lower=i.lower
        upper=i.upper

        if upper==-1:
            upper="*"

        if outString:
            outString = outString +","

        if lower==0 and upper=="*":
            outString=outString+"*"
        else:
            if lower!=upper:
                outString=outString+str(lower)+".."+str(upper)
            else:
                outString=outString+str(lower)
    
    return outString


def fromStringToMultiplicity(s):

    """
    fromStringToMultiplicity creates an Multiplicity instance from
    a given string containing a multiplicity range such as '1..5', '*' or
    '2..5,7..10'

    Example:
     testlist='2..  7,  10.. 29, 23..2'
     m=fromStringToMultiplicity(testlist)
     assert(m.range[0].lower==2 and m.range[0].upper==7)
     assert(m.range[1].lower==10 and m.range[1].upper==29)
     assert(m.range[2].lower==2 and m.range[2].upper==23)
     
    It returns None if the string is empty or contains an invalid
    multiplicty range.    
    """

    s=string.replace(s," ","")
    list=string.split(s,",")

    if len(list)==0:
        return None

    m=Multiplicity()

    for temp in list:                             
        r=string.split(temp,"..")
 
        #If only  element x in list, lower=x and upper=x
        if len(r)==1:     
            r.append(r[0])

       # r[0]=string.strip(r[0])
        if r[0]=='*':
            r[0]=0
            r.append(-1)
        else:
            try:
                r[0]=int(r[0])
            except ValueError:
                return None
      
        if r[1]=='*':
            r[1]=-1
        else:
            try:
                r[1]=int(r[1])
            except ValueError:
                return None

        
        if r[1] != -1 and r[0] > r[1] or r[0]==-1:
            r[0],r[1]=r[1],r[0] #Swap

           
        if len(r)==3 and r[1]!=-1: #if input is i.e(*..5) swap to (5..*)
            r[0]=r[1]
            r[1]=r[2]
        
        m.range.insert(MultiplicityRange(lower=r[0],upper=r[1]))
        #for loop ends
   
        
    #creates a new multiplicity instance with the given multiplicities sorted!    
    return m

def fromAttributeToString(attr):
    """
    fromAttributeToString takes the attributes from the Attribute instance and
    converts them into a string. This string is then used for proper output in the
    class diagram, i.e. ([visibility][name]:[type]=[body]), +x:int=5...

    Example:
    
    attr=Attribute()
    attr.name=\"theAttr\"
    myExp=Expression()
    myExp.body=\"Hello World!\"
    myExp.language=\"\"
    attr.initialValue=myExp
    clfier=Classifier(name=\"String\")
    attr.type=clfier
    attr.visibility=VisibilityKind.vk_protected
    
    assert(fromAttributeToString(attr)==\"#theAttr:String=Hello World!\")
    """
    
    s=""
    if attr.visibility == VisibilityKind.vk_public:
        s=s+"+"
    elif attr.visibility == VisibilityKind.vk_private:
        s=s+"-"
    elif attr.visibility == VisibilityKind.vk_protected:
        s=s+"#"
    elif attr.visibility == VisibilityKind.vk_package:
        s=s+"~"

    if attr.name:
        s=s+attr.name
    if attr.type:
        s=s+":"+attr.type.name
    if attr.initialValue and attr.initialValue.body:
        s=s+"="+attr.initialValue.body
    
    if s=='+':
        return None
    else:
        return s

    

def fromBehavioralFeatureToString(bf):
    '''
    fromBehaviorToString takes the name, parameters, type (and kind), etc. from
    the BehavioralFeature instance for output to be printed in the diagram...

    Example:
    op=Operation(name="add")
    op.parameter.insert(Parameter(name="x",type=t))
    op.parameter.insert(Parameter(kind=ParameterDirectionKind.pdk_return, type=t))
    op.parameter.insert(Parameter(name="y",type=t))
    op.visibility=VisibilityKind.vk_private
    assert(fromBehavioralFeatureToString(op)=="-add(x:int,y:int):int")

    According to specifications if a BehavioralFeature returns nothing (i.e. void)
    the return type should be omitted.
    '''

    
    s=""
    if bf.visibility == VisibilityKind.vk_public:
        s=s+"+"
    elif bf.visibility == VisibilityKind.vk_private:
        s=s+"-"
    elif bf.visibility == VisibilityKind.vk_protected:
        s=s+"#"
    elif bf.visibility == VisibilityKind.vk_package:
        s=s+"~"
    first=1
    end="" #according to "the bible" it should be nothing
    s=s+bf.name+"("
    for p in bf.parameter:
        if p.kind==ParameterDirectionKind.pdk_return and p.type and not p.type.name == "void":            
            end+=":"+p.type.name

        if not first and p.name and p.kind!=ParameterDirectionKind.pdk_return:
            s=s+','

        if p.name and p.kind!=ParameterDirectionKind.pdk_return:       
            s=s+p.name
            first=0

        if p.type and p.type.name!="" and p.name and p.kind!=ParameterDirectionKind.pdk_return:
            s=s+":"+p.type.name
                         
    s=s+")"+end
                
    return s

def fromParameterToString(p):
    '''fromParameterToString returns the textual representation of a parameter according to the specification.

    Example:
    t2=Class(name="String")
    p=Parameter(name="name",type=t2)
    exp=Expression()
    exp.body="Hello World"
    p.kind=ParameterDirectionKind.pdk_inout
    p.defaultValue=exp
    assert(fromParameterToString(p)=="in-out name:String=Hello World")
    '''
    
    s=""
    if p.kind==ParameterDirectionKind.pdk_in:
        s+="in "
    elif p.kind==ParameterDirectionKind.pdk_inout:
        s+="in-out "
    elif p.kind==ParameterDirectionKind.pdk_out:
        s+="out "
    elif p.kind==ParameterDirectionKind.pdk_return:
        s+="return "
    if p.name!="":
        s+=p.name
    if p.type:
        if p.type.name!="":
            s+=":"
        s+=p.type.name
        
    if p.defaultValue and p.defaultValue.body !="":
        s+="="+p.defaultValue.body
        
    return s

def fromOrderingToString(ae):
    """fromOrderingToString gets the orderingkind from an associationEnd so that it will be easier to print relevant output to the screen..."""
    s=""
    if ae.ordering==OrderingKind.ok_ordered:
        return "{ordered}"
    else:
        return s


def fromVisibilityToString(ae):
    """fromVisibilityToString takes an AssociationEnd Rolename as the argument and returns the given visibility of the name e.g +specification=public..."""
    s=""
    
    if ae.visibility == VisibilityKind.vk_public:
        s=s+"+"
    elif ae.visibility == VisibilityKind.vk_private:
        s=s+"-"
    elif ae.visibility == VisibilityKind.vk_protected:
        s=s+"#"
        
    return s

def fromFQPToElement(s,model):
    """fromFQPToElement takes a FullyQualifiedPath in the form of a string and a model and
    returns a reference to that particular element (if it exists).

    If the element does not exist, it returns None.
    """
    if not model:
        return None
    
    names=string.split(s,"::")

    for e in model.ownedElement:
    
        if e.name==names[0] and len(names)==1:
  
            return e
        elif len(names)>1:
  
            if e.name==names[0]:
  
                names=names[1:]
                return fromFQPToElement(string.join(names,"::"),e)
    #out of elements..
    return None

def convertSimpleToCompositeState(state):
        assert(isinstance(state,SimpleState))
 
        # this is a really dirty hack
        # and it is not undoable
        state.__setclass__(CompositeState)
        state.subvertex=[]
        
        state.isConcurrent=0
        state.isRegion=0

        return state

--- NEW FILE: UML14template.py ---


class Association:
    def wfrAssociation1(self):
        return self.allConnections().forAll(
            lambda r1,r2: implies(r1.name==r2.name,r1==r2))
    def wfrAssociation2(self):
        return self.allConnections().select(lambda c: c.aggregation != AggregationKind.ak_none).size()<=1
    def wfrAssociation3(self):
        return implies(self.allConnections().size()>=3,
                       self.allConnections().forAll(
            lambda c: c.aggregation == AggregationKind.ak_none))

    def allConnections(self):
        return self.connection
                                            
class Classifier:
    def allFeatures(self):
        return self.feature
    
    def allOperations(self):
        return self.allFeatures().select(lambda f: f.oclIsKindOf(Operation))

    def allMethods(self):
        return self.allFeatures().select(lambda f: f.oclIsKindOf(Method))

class Method:
    def wfrHasSameSignature(self):
        op = self.specification
        if not op:
            return None
        if len(self.parameter) != len(op.parameter):
            return None
        x = 1
        for i in range(len(self.parameter)):
            pm, po = self.parameter[i], op.parameter[i]
            x = x and (pm.name == po.name)
            x = x and (pm.type.name == po.type.name)
            x = x and (pm.kind == po.kind)
        return x

class GeneralizableElement:
    def wfrCanNotGeneralizeItself(self):
        checked = []
        parents = []
        for i in self.generalization:
            parents.append(i)
            
        while len(parents) > 0:
            p = parents.pop()
            checked.append(p)
            p = p.parent
            if p == self:
                return 0
            addthese = p.generalization
            for i in addthese:
                if not i in checked and not i in parents:
                    parents.append(i)
        return 1

    def wfrCanNotGeneralizeSameElementTwice(self):
        above = []
        for i in self.generalization:
            if i.parent in above:
                return 0
            above.append(i.parent)
        return 1

class Class:
    def wfrClass1(self):
        "If a Class is concrete, all the Operations of the Class should have a realizing Method in the full descriptor [1.4,01.02.01,2-60]"
        return self.isAbstract or self.allOperations().forAll(lambda op: self.allMethods().exist(lambda m: m.specification.asSet().includes(op)))
        
class Transition:
    def getDescription(self):
        text=''
        if self.trigger:
            text=self.trigger.getDescription()
        if self.guard:
            text=text+'['+self.guard.expression.body+']'
        if self.effect:
            text=text+'/'+self.effect.script.body
        return text

class SignalEvent:
    def getDescription(self):
        return self.signal.name

class CallEvent:
    def getDescription(self):
        return self.operation.name

class TimeEvent:
    def getDescription(self):
        return self.when

class ChangeEvent:
    def getDescription(self):
        return self.changeExpression


class CompositeState:
    def wfrCompositeState1(self):
        "A composite state can have at most one initial vertex"
        return self.subvertex.select(
            lambda v: v.oclIsKindOf(Pseudostate) and v.kind== PseudostateKind.pk_initial).size() <=1
    
    def wfrCompositeState2(self):
        "A composite state can have at most one deep history vertex"
        return self.subvertex.select(
            lambda v: v.oclIsKindOf(Pseudostate) and v.kind== PseudostateKind.pk_deepHistory).size() <=1

    def wfrCompositeState3(self):
        "A composite state can have at most one shallow history vertex"
        return self.subvertex.select(
            lambda v: v.oclIsKindOf(Pseudostate) and v.kind== PseudostateKind.pk_shallowHistory).size() <=1

    def wfrCompositeState4(self):
        "There have to be at least two composite substates in a concurrent composite state"
        return implies(self.isConcurrent,
                       self.subvertex.select(lambda v:
                                             v.oclIsKindOf(CompositeState)).size()>=2)

    def wfrCompositeState5(self):
        "A concurrent state can only have composite states as substates"
        return implies(self.isConcurrent,
                       self.subvertex.forAll(lambda s:
                                             s.oclIsKindOf(CompositeState)))

    def wfrCompositeState6(self):
        "The substates of a composite state are part of only that composite state"
        return self.subvertex.forAll(lambda s: s.container.asSet().size()==1 and s.container == self)


class FinalState:

    def wfrFinalState1(self):
        "A final state cannot have any outgoing transitions"
        return self.outgoing.size()==0


class Pseudostate:

    def wfrPseudostate1(self):
        "An initial vertex can have at most one outgoing transition and no incoming transitions"
        return implies(self.kind == PseudostateKind.pk_initial,
                       self.outgoing.size()<=1 and self.incoming.isEmpty())

    def wftPseudostate2(self):
        "History vertices can have at most one outgoing transition"
        return implies(self.kind == PseudostateKind.pk_deepHistory or self.kind== PseudostateKind.pk_shallowHistory,
                       self.outgoing.size()<=1)