java.lang.Object

cruise.umple.compiler.UmpleTrait

public class UmpleTrait
extends UmpleClassifier

An UmpleTrait can contain attributes, associations, state machines and methods. It can also have various other information such as a key (to identify uniqueness), code to inject into generated code, and comments. It can be tagged with various patterns. --- before addDepend { if (depends.contains(aDepend)) { return false; } } --- before setImmutable { if (!canBeImmutable()) { return false; } } --- before addAssociationVariable { if (!immutabilityAssociationRulesSatisfied(aAssociationVariable, this.isImmutable())) { return false; } } --- before setExtendsTrait { if (!enforceImmutabilityInheritanceRules(aExtendsClass)) { return false; } } --------------------------------------------------------------------------------------------- ------------------------------------class end------------------------------------------------ --------------------------------------------------------------------------------------------- --------------------------------------------------------------------------------------------- ------------------------------------class start---------------------------------------------- ---------------------------------------------------------------------------------------------

Constructor Summary

Constructors

Constructor Description

UmpleTrait(java.lang.String aName, UmpleModel aSourceModel)

Method Summary

Modifier and Type	Method	Description
`boolean`	`addAssociation(Association aAssociation)`
`boolean`	`addAssociationVariable(AssociationVariable aAssociationVariable)`
`boolean`	`addAssociationVariableAt(AssociationVariable aAssociationVariable, int index)`
`boolean`	`addAttribute(Attribute aAttribute)`
`boolean`	`addAttributeAt(Attribute aAttribute, int index)`
`boolean`	`addCodeInjection(CodeInjection aCodeInjection)`
`boolean`	`addCodeInjectionAt(CodeInjection aCodeInjection, int index)`
`boolean`	`addComment(Comment aComment)`
`boolean`	`addCommentAt(Comment aComment, int index)`
`boolean`	`addConstraintTree(ConstraintTree aConstraintTree)`
`boolean`	`addConstraintTreeAt(ConstraintTree aConstraintTree, int index)`
`boolean`	`addExtendsTrait(UmpleTrait aExtendsTrait)`
`boolean`	`addExtendsTraitAt(UmpleTrait aExtendsTrait, int index)`
`boolean`	`addGeneralTemplateParameter(GeneralTemplateParameter aGeneralTemplateParameter)`
`boolean`	`addGeneralTemplateParameterAt(GeneralTemplateParameter aGeneralTemplateParameter, int index)`
`boolean`	`addGeneralTPApplied(GeneralTPApplied aGeneralTPApplied)`
`boolean`	`addGeneralTPAppliedAt(GeneralTPApplied aGeneralTPApplied, int index)`
`boolean`	`addOrMoveAssociationVariableAt(AssociationVariable aAssociationVariable, int index)`
`boolean`	`addOrMoveAttributeAt(Attribute aAttribute, int index)`
`boolean`	`addOrMoveCodeInjectionAt(CodeInjection aCodeInjection, int index)`
`boolean`	`addOrMoveCommentAt(Comment aComment, int index)`
`boolean`	`addOrMoveConstraintTreeAt(ConstraintTree aConstraintTree, int index)`
`boolean`	`addOrMoveExtendsTraitAt(UmpleTrait aExtendsTrait, int index)`
`boolean`	`addOrMoveGeneralTemplateParameterAt(GeneralTemplateParameter aGeneralTemplateParameter, int index)`
`boolean`	`addOrMoveGeneralTPAppliedAt(GeneralTPApplied aGeneralTPApplied, int index)`
`boolean`	`addOrMovePostCondAt(Postcondition aPostCond, int index)`
`boolean`	`addOrMovePreCondAt(Precondition aPreCond, int index)`
`boolean`	`addOrMoveRequiredInterfaceAt(UmpleInterface aRequiredInterface, int index)`
`boolean`	`addOrMoveRequirementAt(Requirement aRequirement, int index)`
`boolean`	`addOrMoveStateMachineAt(StateMachine aStateMachine, int index)`
`boolean`	`addOrMoveSubClassAt(UmpleClass aSubClass, int index)`
`boolean`	`addOrMoveSubTraitAt(UmpleTrait aSubTrait, int index)`
`boolean`	`addOrMoveUmpleTestCaseAt(UmpleTestCase aUmpleTestCase, int index)`
`boolean`	`addPostCond(Postcondition aPostCond)`
`boolean`	`addPostCondAt(Postcondition aPostCond, int index)`
`boolean`	`addPreCond(Precondition aPreCond)`
`boolean`	`addPreCondAt(Precondition aPreCond, int index)`
`boolean`	`addRequiredInterface(UmpleInterface aRequiredInterface)`
`boolean`	`addRequiredInterfaceAt(UmpleInterface aRequiredInterface, int index)`
`boolean`	`addRequirement(Requirement aRequirement)`
`boolean`	`addRequirementAt(Requirement aRequirement, int index)`
`boolean`	`addStateMachine(StateMachine aStateMachine)`
`boolean`	`addStateMachineAt(StateMachine aStateMachine, int index)`
`boolean`	`addSubClass(UmpleClass aSubClass)`
`boolean`	`addSubClassAt(UmpleClass aSubClass, int index)`
`boolean`	`addSubTrait(UmpleTrait aSubTrait)`
`boolean`	`addSubTraitAt(UmpleTrait aSubTrait, int index)`
`boolean`	`addUmpleTestCase(UmpleTestCase aUmpleTestCase)`
`boolean`	`addUmpleTestCaseAt(UmpleTestCase aUmpleTestCase, int index)`
`boolean`	`addUnimplementedMethod(Method aUnimplementedMethod)`
`void`	`delete()`
`Association`	`getAssociation(int index)`
`Association[]`	`getAssociations()`
`AssociationVariable`	`getAssociationVariable(int index)`
`AssociationVariable`	`getAssociationVariable(java.lang.String name)`
`java.util.List<AssociationVariable>`	`getAssociationVariables()`	The associations contained within the Umple trait.
`Attribute`	`getAttribute(int index)`
`Attribute`	`getAttribute(java.lang.String name)`
`java.util.List<Attribute>`	`getAttributes()`	The attributes contained within the Umple trait.
`CodeInjection`	`getCodeInjection(int index)`
`java.util.List<CodeInjection>`	`getCodeInjections()`
`Comment`	`getComment(int index)`
`java.util.List<Comment>`	`getComments()`	The comments associated with the Umple Trait (such as the Javadoc above it).
`ConstraintTree`	`getConstraintTree(int index)`
`java.util.List<ConstraintTree>`	`getConstraintTrees()`	The possible Constraints related to the Umple Trait
`UmpleTrait`	`getExtendsTrait(int index)`
`java.util.List<UmpleTrait>`	`getExtendsTraits()`	The Umple Trait's super Traits (if there are ones).
`GeneralTemplateParameter`	`getGeneralTemplateParameter(int index)`
`GeneralTemplateParameter`	`getGeneralTemplateParameterByName(java.lang.String name)`
`java.lang.Integer`	`getGeneralTemplateParameterIndexByName(java.lang.String name, java.lang.String type)`
`java.util.List<GeneralTemplateParameter>`	`getGeneralTemplateParameters()`	The template parameters which are specified when traits are defined.
`GeneralTPApplied`	`getGeneralTPApplied(int index)`
`GeneralTPApplied`	`getGeneralTPAppliedByName(java.lang.String name)`
`java.util.List<GeneralTPApplied>`	`getGeneralTPApplieds()`	This is used to assign inheritance parameters.
`boolean`	`getIsAbstract()`	Specifies whether or not the Umple class is an abstract class.
`boolean`	`getIsSingleton()`	Specifies whether or not the Umple trait is a singleton.
`Key`	`getKey()`
`Method`	`getMethod(Method comparedMethod)`
`Postcondition`	`getPostCond(int index)`
`java.util.List<Postcondition>`	`getPostConds()`	The possible Preconditions related to the Umple Trait
`Precondition`	`getPreCond(int index)`
`java.util.List<Precondition>`	`getPreConds()`	The possible Preconditions related to the Umple Trait
`UmpleInterface`	`getRequiredInterface(int index)`
`java.util.List<UmpleInterface>`	`getRequiredInterfaces()`	This is used to assign required interfaces
`Requirement`	`getRequirement(int index)`
`java.util.List<Requirement>`	`getRequirements()`	The requirement associated with the Umple Trait (such as the Javadoc above it).
`StateMachine`	`getStateMachine(int index)`
`StateMachine`	`getStateMachine(java.lang.String name)`
`java.util.List<StateMachine>`	`getStateMachines()`
`UmpleClass`	`getSubClass(int index)`
`java.util.List<UmpleClass>`	`getSubClasses()`
`UmpleTrait`	`getSubTrait(int index)`
`java.util.List<UmpleTrait>`	`getSubTraits()`
`UmpleTestCase`	`getUmpleTestCase(int index)`
`java.util.List<UmpleTestCase>`	`getUmpleTestCases()`	trait test cases
`Method`	`getUnimplementedMethod(int index)`
`Method[]`	`getUnimplementedMethods()`
`UniqueIdentifier`	`getUniqueIdentifier()`
`boolean`	`hasAssociations()`
`boolean`	`hasAssociationVariables()`
`boolean`	`hasAttributes()`
`boolean`	`hasCascadeMethod(Method aMethod, java.lang.Boolean inAbstract)`
`boolean`	`hasCodeInjections()`
`boolean`	`hasComments()`
`boolean`	`hasConstraintTrees()`
`boolean`	`hasDefinedParameter(java.lang.String name, java.lang.String type)`	This section is related to codes which is going to support general templates for traits -------------------------------------------------------------------------------------- ----------------------------------start-----------------------------------------------
`boolean`	`hasExtendsTraits()`
`boolean`	`hasGeneralTemplateParameter(java.lang.String name)`
`boolean`	`hasGeneralTemplateParameters()`
`boolean`	`hasGeneralTPApplieds()`
`boolean`	`hasMethod(Method comparedMethod)`
`boolean`	`hasPostConds()`
`boolean`	`hasPreConds()`
`boolean`	`hasRequiredInterfaces()`
`boolean`	`hasRequirements()`
`boolean`	`hasStateMachines()`
`boolean`	`hasSubClasses()`
`boolean`	`hasSubTraits()`
`boolean`	`hasUmpleTestCases()`
`boolean`	`hasUnimplementedMethods()`
`boolean`	`hasUniqueIdentifier()`
`protected boolean`	`immutabilityAssociationRulesSatisfied(AssociationVariable myAV, boolean myTraitImmutable)`
`protected static boolean`	`immutabilityAssociationRulesSatisfied(AssociationVariable myAV, UmpleTrait myTrait, boolean myTraitImmutable, AssociationVariable yourAV, UmpleTrait yourTrait, boolean yourTraitImmutable)`
`int`	`indexOfAssociation(Association aAssociation)`
`int`	`indexOfAssociationVariable(AssociationVariable aAssociationVariable)`
`int`	`indexOfAttribute(Attribute aAttribute)`
`int`	`indexOfCodeInjection(CodeInjection aCodeInjection)`
`int`	`indexOfComment(Comment aComment)`
`int`	`indexOfConstraintTree(ConstraintTree aConstraintTree)`
`int`	`indexOfExtendsTrait(UmpleTrait aExtendsTrait)`
`int`	`indexOfGeneralTemplateParameter(GeneralTemplateParameter aGeneralTemplateParameter)`
`int`	`indexOfGeneralTPApplied(GeneralTPApplied aGeneralTPApplied)`
`int`	`indexOfPostCond(Postcondition aPostCond)`
`int`	`indexOfPreCond(Precondition aPreCond)`
`int`	`indexOfRequiredInterface(UmpleInterface aRequiredInterface)`
`int`	`indexOfRequirement(Requirement aRequirement)`
`int`	`indexOfStateMachine(StateMachine aStateMachine)`
`int`	`indexOfSubClass(UmpleClass aSubClass)`
`int`	`indexOfSubTrait(UmpleTrait aSubTrait)`
`int`	`indexOfUmpleTestCase(UmpleTestCase aUmpleTestCase)`
`int`	`indexOfUnimplementedMethod(Method aUnimplementedMethod)`
`boolean`	`isImmutable()`
`boolean`	`isIsAbstract()`
`boolean`	`isIsSingleton()`
`boolean`	`isUmpleTrait()`
`static int`	`minimumNumberOfAssociationVariables()`
`static int`	`minimumNumberOfAttributes()`
`static int`	`minimumNumberOfCodeInjections()`
`static int`	`minimumNumberOfComments()`
`static int`	`minimumNumberOfConstraintTrees()`
`static int`	`minimumNumberOfExtendsTraits()`
`static int`	`minimumNumberOfGeneralTemplateParameters()`
`static int`	`minimumNumberOfGeneralTPApplieds()`
`static int`	`minimumNumberOfPostConds()`
`static int`	`minimumNumberOfPreConds()`
`static int`	`minimumNumberOfRequiredInterfaces()`
`static int`	`minimumNumberOfRequirements()`
`static int`	`minimumNumberOfStateMachines()`
`static int`	`minimumNumberOfSubClasses()`
`static int`	`minimumNumberOfSubTraits()`
`static int`	`minimumNumberOfUmpleTestCases()`
`int`	`numberOfAssociations()`
`int`	`numberOfAssociationVariables()`
`int`	`numberOfAttributes()`
`int`	`numberOfCodeInjections()`
`int`	`numberOfComments()`
`int`	`numberOfConstraintTrees()`
`int`	`numberOfExtendsTraits()`
`int`	`numberOfGeneralTemplateParameters()`
`int`	`numberOfGeneralTPApplieds()`
`int`	`numberOfPostConds()`
`int`	`numberOfPreConds()`
`int`	`numberOfRequiredInterfaces()`
`int`	`numberOfRequirements()`
`int`	`numberOfStateMachines()`
`int`	`numberOfSubClasses()`
`int`	`numberOfSubTraits()`
`int`	`numberOfUmpleTestCases()`
`int`	`numberOfUnimplementedMethods()`
`boolean`	`removeAssociation(Association aAssociation)`
`boolean`	`removeAssociationVariable(AssociationVariable aAssociationVariable)`
`boolean`	`removeAttribute(Attribute aAttribute)`
`boolean`	`removeCodeInjection(CodeInjection aCodeInjection)`
`boolean`	`removeComment(Comment aComment)`
`boolean`	`removeConstraintTree(ConstraintTree aConstraintTree)`
`boolean`	`removeExtendsTrait(UmpleTrait aExtendsTrait)`
`boolean`	`removeGeneralTemplateParameter(GeneralTemplateParameter aGeneralTemplateParameter)`
`boolean`	`removeGeneralTPApplied(GeneralTPApplied aGeneralTPApplied)`
`boolean`	`removePostCond(Postcondition aPostCond)`
`boolean`	`removePreCond(Precondition aPreCond)`
`boolean`	`removeRequiredInterface(UmpleInterface aRequiredInterface)`
`boolean`	`removeRequirement(Requirement aRequirement)`
`boolean`	`removeStateMachine(StateMachine aStateMachine)`
`boolean`	`removeSubClass(UmpleClass aSubClass)`
`boolean`	`removeSubTrait(UmpleTrait aSubTrait)`
`boolean`	`removeUmpleTestCase(UmpleTestCase aUmpleTestCase)`
`boolean`	`removeUnimplementedMethod(Method aUnimplementedMethod)`
`protected boolean`	`setAncestorIsImmutable(boolean isImmutable)`
`void`	`setDefinedParameterType(java.lang.String name, java.lang.String type)`
`boolean`	`setExtendsTrait(UmpleTrait aExtendsTrait)`
`boolean`	`setImmutable()`
`boolean`	`setIsAbstract(boolean aIsAbstract)`
`boolean`	`setIsSingleton(boolean aIsSingleton)`
`boolean`	`setKey(Key aKey)`
`boolean`	`setUniqueIdentifier(UniqueIdentifier aNewUniqueIdentifier)`
`java.lang.String`	`toString()`

Methods inherited from class cruise.umple.compiler.UmpleClassifier

addConstant, addConstantAt, addDepend, addDependAt, addMethod, addMethodAt, addModelConstraint, addModelConstraintAt, addOrMoveConstantAt, addOrMoveDependAt, addOrMoveMethodAt, addOrMoveModelConstraintAt, getConstant, getConstants, getDepend, getDepends, getDistributeTechnology, getExtendsToken, getIsDistributable, getMethod, getMethods, getModelConstraint, getModelConstraints, getRelativePath, getSourceModel, hasConstants, hasDepends, hasExtendsToken, hasMethods, hasModelConstraints, indexOfConstant, indexOfDepend, indexOfMethod, indexOfModelConstraint, isIsDistributable, minimumNumberOfConstants, minimumNumberOfDepends, minimumNumberOfMethods, minimumNumberOfModelConstraints, numberOfConstants, numberOfDepends, numberOfMethods, numberOfModelConstraints, removeConstant, removeDepend, removeMethod, removeModelConstraint, setDistributeTechnology, setExtendsToken, setIsDistributable, setSourceModel

Methods inherited from class cruise.umple.compiler.UmpleElement

addEndPosition, addEndPositionAt, addNamespace, addOrMoveEndPositionAt, addOrMovePositionAt, addPosition, addPositionAt, appendExtraCode, appendExtraCode, appendExtraCode, getCoordinates, getDisplayColor, getEndPosition, getEndPositions, getExtraCode, getHasMainMethod, getIsInternal, getModifier, getName, getNamespace, getNameSpace, getNamespaces, getPackageName, getPosition, getPositions, hasEndPositions, hasExtraCode, hasNamespaces, hasPositions, indexOfEndPosition, indexOfNamespace, indexOfPosition, isHasMainMethod, isIsInternal, isUmpleClass, isUmpleInterface, minimumNumberOfEndPositions, minimumNumberOfPositions, numberOfEndPositions, numberOfNamespaces, numberOfPositions, removeEndPosition, removeNamespace, removePosition, resetExtraCode, setCoordinates, setDisplayColor, setHasMainMethod, setIsInternal, setModifier, setName, setNameSpace, setPackageName

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Constructor Details
- UmpleTrait
  
  public UmpleTrait(java.lang.String aName, UmpleModel aSourceModel)
Method Details
- setIsAbstract
  
  public boolean setIsAbstract(boolean aIsAbstract)
- setIsSingleton
  
  public boolean setIsSingleton(boolean aIsSingleton)
- addAssociation
  
  public boolean addAssociation(Association aAssociation)
- removeAssociation
  
  public boolean removeAssociation(Association aAssociation)
- addUnimplementedMethod
  
  public boolean addUnimplementedMethod(Method aUnimplementedMethod)
- removeUnimplementedMethod
  
  public boolean removeUnimplementedMethod(Method aUnimplementedMethod)
- setKey
  
  public boolean setKey(Key aKey)
- getIsAbstract
  
  public boolean getIsAbstract()
  
  Specifies whether or not the Umple class is an abstract class.
- getIsSingleton
  
  public boolean getIsSingleton()
  
  Specifies whether or not the Umple trait is a singleton.
- getAssociation
  
  public Association getAssociation(int index)
- getAssociations
  
  public Association[] getAssociations()
- numberOfAssociations
  
  public int numberOfAssociations()
- hasAssociations
  
  public boolean hasAssociations()
- indexOfAssociation
  
  public int indexOfAssociation(Association aAssociation)
- getUnimplementedMethod
  
  public Method getUnimplementedMethod(int index)
- getUnimplementedMethods
  
  public Method[] getUnimplementedMethods()
- numberOfUnimplementedMethods
  
  public int numberOfUnimplementedMethods()
- hasUnimplementedMethods
  
  public boolean hasUnimplementedMethods()
- indexOfUnimplementedMethod
  
  public int indexOfUnimplementedMethod(Method aUnimplementedMethod)
- getKey
  
  public Key getKey()
- isIsAbstract
  
  public boolean isIsAbstract()
- isIsSingleton
  
  public boolean isIsSingleton()
- getCodeInjection
  
  public CodeInjection getCodeInjection(int index)
- getCodeInjections
  
  public java.util.List<CodeInjection> getCodeInjections()
- numberOfCodeInjections
  
  public int numberOfCodeInjections()
- hasCodeInjections
  
  public boolean hasCodeInjections()
- indexOfCodeInjection
  
  public int indexOfCodeInjection(CodeInjection aCodeInjection)
- getPreCond
  
  public Precondition getPreCond(int index)
- getPreConds
  
  public java.util.List<Precondition> getPreConds()
  
  The possible Preconditions related to the Umple Trait
- numberOfPreConds
  
  public int numberOfPreConds()
- hasPreConds
  
  public boolean hasPreConds()
- indexOfPreCond
  
  public int indexOfPreCond(Precondition aPreCond)
- getPostCond
  
  public Postcondition getPostCond(int index)
- getPostConds
  
  public java.util.List<Postcondition> getPostConds()
  
  The possible Preconditions related to the Umple Trait
- numberOfPostConds
  
  public int numberOfPostConds()
- hasPostConds
  
  public boolean hasPostConds()
- indexOfPostCond
  
  public int indexOfPostCond(Postcondition aPostCond)
- getConstraintTree
  
  public ConstraintTree getConstraintTree(int index)
- getConstraintTrees
  
  public java.util.List<ConstraintTree> getConstraintTrees()
  
  The possible Constraints related to the Umple Trait
- numberOfConstraintTrees
  
  public int numberOfConstraintTrees()
- hasConstraintTrees
  
  public boolean hasConstraintTrees()
- indexOfConstraintTree
  
  public int indexOfConstraintTree(ConstraintTree aConstraintTree)
- getExtendsTrait
  
  public UmpleTrait getExtendsTrait(int index)
- getExtendsTraits
  
  public java.util.List<UmpleTrait> getExtendsTraits()
  
  The Umple Trait's super Traits (if there are ones).
- numberOfExtendsTraits
  
  public int numberOfExtendsTraits()
- hasExtendsTraits
  
  public boolean hasExtendsTraits()
- indexOfExtendsTrait
  
  public int indexOfExtendsTrait(UmpleTrait aExtendsTrait)
- getUniqueIdentifier
  
  public UniqueIdentifier getUniqueIdentifier()
- hasUniqueIdentifier
  
  public boolean hasUniqueIdentifier()
- getAttribute
  
  public Attribute getAttribute(int index)
- getAttributes
  
  public java.util.List<Attribute> getAttributes()
  
  The attributes contained within the Umple trait.
- numberOfAttributes
  
  public int numberOfAttributes()
- hasAttributes
  
  public boolean hasAttributes()
- indexOfAttribute
  
  public int indexOfAttribute(Attribute aAttribute)
- getAssociationVariable
  
  public AssociationVariable getAssociationVariable(int index)
- getAssociationVariables
  
  public java.util.List<AssociationVariable> getAssociationVariables()
  
  The associations contained within the Umple trait.
- numberOfAssociationVariables
  
  public int numberOfAssociationVariables()
- hasAssociationVariables
  
  public boolean hasAssociationVariables()
- indexOfAssociationVariable
  
  public int indexOfAssociationVariable(AssociationVariable aAssociationVariable)
- getComment
  
  public Comment getComment(int index)
- getComments
  
  public java.util.List<Comment> getComments()
  
  The comments associated with the Umple Trait (such as the Javadoc above it).
- numberOfComments
  
  public int numberOfComments()
- hasComments
  
  public boolean hasComments()
- indexOfComment
  
  public int indexOfComment(Comment aComment)
- getRequirement
  
  public Requirement getRequirement(int index)
- getRequirements
  
  public java.util.List<Requirement> getRequirements()
  
  The requirement associated with the Umple Trait (such as the Javadoc above it).
- numberOfRequirements
  
  public int numberOfRequirements()
- hasRequirements
  
  public boolean hasRequirements()
- indexOfRequirement
  
  public int indexOfRequirement(Requirement aRequirement)
- getGeneralTemplateParameter
  
  public GeneralTemplateParameter getGeneralTemplateParameter(int index)
- getGeneralTemplateParameters
  
  public java.util.List<GeneralTemplateParameter> getGeneralTemplateParameters()
  
  The template parameters which are specified when traits are defined.
- numberOfGeneralTemplateParameters
  
  public int numberOfGeneralTemplateParameters()
- hasGeneralTemplateParameters
  
  public boolean hasGeneralTemplateParameters()
- indexOfGeneralTemplateParameter
  
  public int indexOfGeneralTemplateParameter(GeneralTemplateParameter aGeneralTemplateParameter)
- getGeneralTPApplied
  
  public GeneralTPApplied getGeneralTPApplied(int index)
- getGeneralTPApplieds
  
  public java.util.List<GeneralTPApplied> getGeneralTPApplieds()
  
  This is used to assign inheritance parameters.
- numberOfGeneralTPApplieds
  
  public int numberOfGeneralTPApplieds()
- hasGeneralTPApplieds
  
  public boolean hasGeneralTPApplieds()
- indexOfGeneralTPApplied
  
  public int indexOfGeneralTPApplied(GeneralTPApplied aGeneralTPApplied)
- getRequiredInterface
  
  public UmpleInterface getRequiredInterface(int index)
- getRequiredInterfaces
  
  public java.util.List<UmpleInterface> getRequiredInterfaces()
  
  This is used to assign required interfaces
- numberOfRequiredInterfaces
  
  public int numberOfRequiredInterfaces()
- hasRequiredInterfaces
  
  public boolean hasRequiredInterfaces()
- indexOfRequiredInterface
  
  public int indexOfRequiredInterface(UmpleInterface aRequiredInterface)
- getUmpleTestCase
  
  public UmpleTestCase getUmpleTestCase(int index)
- getUmpleTestCases
  
  public java.util.List<UmpleTestCase> getUmpleTestCases()
  
  trait test cases
- numberOfUmpleTestCases
  
  public int numberOfUmpleTestCases()
- hasUmpleTestCases
  
  public boolean hasUmpleTestCases()
- indexOfUmpleTestCase
  
  public int indexOfUmpleTestCase(UmpleTestCase aUmpleTestCase)
- getStateMachine
  
  public StateMachine getStateMachine(int index)
- getStateMachines
  
  public java.util.List<StateMachine> getStateMachines()
- numberOfStateMachines
  
  public int numberOfStateMachines()
- hasStateMachines
  
  public boolean hasStateMachines()
- indexOfStateMachine
  
  public int indexOfStateMachine(StateMachine aStateMachine)
- getSubClass
  
  public UmpleClass getSubClass(int index)
- getSubClasses
  
  public java.util.List<UmpleClass> getSubClasses()
- numberOfSubClasses
  
  public int numberOfSubClasses()
- hasSubClasses
  
  public boolean hasSubClasses()
- indexOfSubClass
  
  public int indexOfSubClass(UmpleClass aSubClass)
- getSubTrait
  
  public UmpleTrait getSubTrait(int index)
- getSubTraits
  
  public java.util.List<UmpleTrait> getSubTraits()
- numberOfSubTraits
  
  public int numberOfSubTraits()
- hasSubTraits
  
  public boolean hasSubTraits()
- indexOfSubTrait
  
  public int indexOfSubTrait(UmpleTrait aSubTrait)
- minimumNumberOfCodeInjections
  
  public static int minimumNumberOfCodeInjections()
- addCodeInjection
  
  public boolean addCodeInjection(CodeInjection aCodeInjection)
- removeCodeInjection
  
  public boolean removeCodeInjection(CodeInjection aCodeInjection)
- addCodeInjectionAt
  
  public boolean addCodeInjectionAt(CodeInjection aCodeInjection, int index)
- addOrMoveCodeInjectionAt
  
  public boolean addOrMoveCodeInjectionAt(CodeInjection aCodeInjection, int index)
- minimumNumberOfPreConds
  
  public static int minimumNumberOfPreConds()
- addPreCond
  
  public boolean addPreCond(Precondition aPreCond)
- removePreCond
  
  public boolean removePreCond(Precondition aPreCond)
- addPreCondAt
  
  public boolean addPreCondAt(Precondition aPreCond, int index)
- addOrMovePreCondAt
  
  public boolean addOrMovePreCondAt(Precondition aPreCond, int index)
- minimumNumberOfPostConds
  
  public static int minimumNumberOfPostConds()
- addPostCond
  
  public boolean addPostCond(Postcondition aPostCond)
- removePostCond
  
  public boolean removePostCond(Postcondition aPostCond)
- addPostCondAt
  
  public boolean addPostCondAt(Postcondition aPostCond, int index)
- addOrMovePostCondAt
  
  public boolean addOrMovePostCondAt(Postcondition aPostCond, int index)
- minimumNumberOfConstraintTrees
  
  public static int minimumNumberOfConstraintTrees()
- addConstraintTree
  
  public boolean addConstraintTree(ConstraintTree aConstraintTree)
- removeConstraintTree
  
  public boolean removeConstraintTree(ConstraintTree aConstraintTree)
- addConstraintTreeAt
  
  public boolean addConstraintTreeAt(ConstraintTree aConstraintTree, int index)
- addOrMoveConstraintTreeAt
  
  public boolean addOrMoveConstraintTreeAt(ConstraintTree aConstraintTree, int index)
- minimumNumberOfExtendsTraits
  
  public static int minimumNumberOfExtendsTraits()
- addExtendsTrait
  
  public boolean addExtendsTrait(UmpleTrait aExtendsTrait)
- removeExtendsTrait
  
  public boolean removeExtendsTrait(UmpleTrait aExtendsTrait)
- addExtendsTraitAt
  
  public boolean addExtendsTraitAt(UmpleTrait aExtendsTrait, int index)
- addOrMoveExtendsTraitAt
  
  public boolean addOrMoveExtendsTraitAt(UmpleTrait aExtendsTrait, int index)
- setUniqueIdentifier
  
  public boolean setUniqueIdentifier(UniqueIdentifier aNewUniqueIdentifier)
- minimumNumberOfAttributes
  
  public static int minimumNumberOfAttributes()
- addAttribute
  
  public boolean addAttribute(Attribute aAttribute)
- removeAttribute
  
  public boolean removeAttribute(Attribute aAttribute)
- addAttributeAt
  
  public boolean addAttributeAt(Attribute aAttribute, int index)
- addOrMoveAttributeAt
  
  public boolean addOrMoveAttributeAt(Attribute aAttribute, int index)
- minimumNumberOfAssociationVariables
  
  public static int minimumNumberOfAssociationVariables()
- addAssociationVariable
  
  public boolean addAssociationVariable(AssociationVariable aAssociationVariable)
- removeAssociationVariable
  
  public boolean removeAssociationVariable(AssociationVariable aAssociationVariable)
- addAssociationVariableAt
  
  public boolean addAssociationVariableAt(AssociationVariable aAssociationVariable, int index)
- addOrMoveAssociationVariableAt
  
  public boolean addOrMoveAssociationVariableAt(AssociationVariable aAssociationVariable, int index)
- minimumNumberOfComments
  
  public static int minimumNumberOfComments()
- addComment
  
  public boolean addComment(Comment aComment)
- removeComment
  
  public boolean removeComment(Comment aComment)
- addCommentAt
  
  public boolean addCommentAt(Comment aComment, int index)
- addOrMoveCommentAt
  
  public boolean addOrMoveCommentAt(Comment aComment, int index)
- minimumNumberOfRequirements
  
  public static int minimumNumberOfRequirements()
- addRequirement
  
  public boolean addRequirement(Requirement aRequirement)
- removeRequirement
  
  public boolean removeRequirement(Requirement aRequirement)
- addRequirementAt
  
  public boolean addRequirementAt(Requirement aRequirement, int index)
- addOrMoveRequirementAt
  
  public boolean addOrMoveRequirementAt(Requirement aRequirement, int index)
- minimumNumberOfGeneralTemplateParameters
  
  public static int minimumNumberOfGeneralTemplateParameters()
- addGeneralTemplateParameter
  
  public boolean addGeneralTemplateParameter(GeneralTemplateParameter aGeneralTemplateParameter)
- removeGeneralTemplateParameter
  
  public boolean removeGeneralTemplateParameter(GeneralTemplateParameter aGeneralTemplateParameter)
- addGeneralTemplateParameterAt
  
  public boolean addGeneralTemplateParameterAt(GeneralTemplateParameter aGeneralTemplateParameter, int index)
- addOrMoveGeneralTemplateParameterAt
  
  public boolean addOrMoveGeneralTemplateParameterAt(GeneralTemplateParameter aGeneralTemplateParameter, int index)
- minimumNumberOfGeneralTPApplieds
  
  public static int minimumNumberOfGeneralTPApplieds()
- addGeneralTPApplied
  
  public boolean addGeneralTPApplied(GeneralTPApplied aGeneralTPApplied)
- removeGeneralTPApplied
  
  public boolean removeGeneralTPApplied(GeneralTPApplied aGeneralTPApplied)
- addGeneralTPAppliedAt
  
  public boolean addGeneralTPAppliedAt(GeneralTPApplied aGeneralTPApplied, int index)
- addOrMoveGeneralTPAppliedAt
  
  public boolean addOrMoveGeneralTPAppliedAt(GeneralTPApplied aGeneralTPApplied, int index)
- minimumNumberOfRequiredInterfaces
  
  public static int minimumNumberOfRequiredInterfaces()
- addRequiredInterface
  
  public boolean addRequiredInterface(UmpleInterface aRequiredInterface)
- removeRequiredInterface
  
  public boolean removeRequiredInterface(UmpleInterface aRequiredInterface)
- addRequiredInterfaceAt
  
  public boolean addRequiredInterfaceAt(UmpleInterface aRequiredInterface, int index)
- addOrMoveRequiredInterfaceAt
  
  public boolean addOrMoveRequiredInterfaceAt(UmpleInterface aRequiredInterface, int index)
- minimumNumberOfUmpleTestCases
  
  public static int minimumNumberOfUmpleTestCases()
- addUmpleTestCase
  
  public boolean addUmpleTestCase(UmpleTestCase aUmpleTestCase)
- removeUmpleTestCase
  
  public boolean removeUmpleTestCase(UmpleTestCase aUmpleTestCase)
- addUmpleTestCaseAt
  
  public boolean addUmpleTestCaseAt(UmpleTestCase aUmpleTestCase, int index)
- addOrMoveUmpleTestCaseAt
  
  public boolean addOrMoveUmpleTestCaseAt(UmpleTestCase aUmpleTestCase, int index)
- minimumNumberOfStateMachines
  
  public static int minimumNumberOfStateMachines()
- addStateMachine
  
  public boolean addStateMachine(StateMachine aStateMachine)
- removeStateMachine
  
  public boolean removeStateMachine(StateMachine aStateMachine)
- addStateMachineAt
  
  public boolean addStateMachineAt(StateMachine aStateMachine, int index)
- addOrMoveStateMachineAt
  
  public boolean addOrMoveStateMachineAt(StateMachine aStateMachine, int index)
- minimumNumberOfSubClasses
  
  public static int minimumNumberOfSubClasses()
- addSubClass
  
  public boolean addSubClass(UmpleClass aSubClass)
- removeSubClass
  
  public boolean removeSubClass(UmpleClass aSubClass)
- addSubClassAt
  
  public boolean addSubClassAt(UmpleClass aSubClass, int index)
- addOrMoveSubClassAt
  
  public boolean addOrMoveSubClassAt(UmpleClass aSubClass, int index)
- minimumNumberOfSubTraits
  
  public static int minimumNumberOfSubTraits()
- addSubTrait
  
  public boolean addSubTrait(UmpleTrait aSubTrait)
- removeSubTrait
  
  public boolean removeSubTrait(UmpleTrait aSubTrait)
- addSubTraitAt
  
  public boolean addSubTraitAt(UmpleTrait aSubTrait, int index)
- addOrMoveSubTraitAt
  
  public boolean addOrMoveSubTraitAt(UmpleTrait aSubTrait, int index)
- delete
  
  public void delete()
  
  Overrides:
  
  delete in class UmpleClassifier
- isUmpleTrait
  
  public boolean isUmpleTrait()
  
  Overrides:
  
  isUmpleTrait in class UmpleElement
- getGeneralTPAppliedByName
  
  public GeneralTPApplied getGeneralTPAppliedByName(java.lang.String name)
- hasGeneralTemplateParameter
  
  public boolean hasGeneralTemplateParameter(java.lang.String name)
- hasCascadeMethod
  
  public boolean hasCascadeMethod(Method aMethod, java.lang.Boolean inAbstract)
- getAttribute
  
  public Attribute getAttribute(java.lang.String name)
- getAssociationVariable
  
  public AssociationVariable getAssociationVariable(java.lang.String name)
- isImmutable
  
  public boolean isImmutable()
- setImmutable
  
  public boolean setImmutable()
- immutabilityAssociationRulesSatisfied
  
  protected boolean immutabilityAssociationRulesSatisfied(AssociationVariable myAV, boolean myTraitImmutable)
- immutabilityAssociationRulesSatisfied
  
  protected static boolean immutabilityAssociationRulesSatisfied(AssociationVariable myAV, UmpleTrait myTrait, boolean myTraitImmutable, AssociationVariable yourAV, UmpleTrait yourTrait, boolean yourTraitImmutable)
- setAncestorIsImmutable
  
  protected boolean setAncestorIsImmutable(boolean isImmutable)
- setExtendsTrait
  
  public boolean setExtendsTrait(UmpleTrait aExtendsTrait)
- getMethod
  
  public Method getMethod(Method comparedMethod)
- getStateMachine
  
  public StateMachine getStateMachine(java.lang.String name)
- hasMethod
  
  public boolean hasMethod(Method comparedMethod)
  
  Overrides:
  
  hasMethod in class UmpleClassifier
- hasDefinedParameter
  
  public boolean hasDefinedParameter(java.lang.String name, java.lang.String type)
  
  This section is related to codes which is going to support general templates for traits -------------------------------------------------------------------------------------- ----------------------------------start-----------------------------------------------
- setDefinedParameterType
  
  public void setDefinedParameterType(java.lang.String name, java.lang.String type)
- getGeneralTemplateParameterIndexByName
  
  public java.lang.Integer getGeneralTemplateParameterIndexByName(java.lang.String name, java.lang.String type)
- getGeneralTemplateParameterByName
  
  public GeneralTemplateParameter getGeneralTemplateParameterByName(java.lang.String name)
- toString
  
  public java.lang.String toString()
  
  Overrides:
  
  toString in class UmpleClassifier

Class UmpleTrait

Constructor Summary

Method Summary

Methods inherited from class cruise.umple.compiler.UmpleClassifier

Methods inherited from class cruise.umple.compiler.UmpleElement

Methods inherited from class java.lang.Object

Constructor Details

Method Details