| UmpleClass |
| hasProxyPattern : Boolean |
| needsDefaultInterface : Boolean |
| isDistributed : Boolean |
| isInternalSerializable : Boolean |
| isDefaultInterfaceRemoteRMI : Boolean |
| level : Integer |
| isInitialized : Boolean |
| filteredin : Boolean |
| isAbstract : Boolean |
| isSingleton : Boolean |
| associations : Association[] |
| unimplementedMethods : Method[] |
| key : Key |
| iAmImmutable : Boolean |
| ancestorIsImmutable : Boolean |
| isStatic : boolean |
| disableAutogeneratedMethodList : String[] |
| propagateCounter : Integer |
| portBindingInformation : PortBindingInformation[] |
| portClass : Boolean |
| emitMethods : TemplateMethod[] |
| templateEmitStringMap : Map<String,TemplateAttributeParser> |
>,
tooltip="class UmpleClass
* An UmpleClass 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, such as 'singleton', meaning that there can only be one instance,
and abstract, meaning it can't have any instances.
* In Umple_Code.ump: Methods for computing complex properties
---------------------------------------------------------------------------------------------
------------------------------------class end------------------------------------------------
---------------------------------------------------------------------------------------------
---------------------------------------------------------------------------------------------
------------------------------------class start----------------------------------------------
---------------------------------------------------------------------------------------------
----------------------------------------------------------
Handle the existing templates in the current umple model.
class UmpleModel {
UmpleTemplate getUmpleTemplate(String name){
for (UmpleTemplate aTemplate : getUmpleTemplates())
{
if (aTemplate.getName().equals(name))
{
return aTemplate;
}
}
return null;
}
public UmpleTemplate addUmpleTemplate(String name)
{
UmpleTemplate newTemplate = getUmpleTemplate(name);
if (newTemplate == null)
{
newTemplate = new UmpleTemplate(name, this);
addUmpleTemplate(newTemplate);
}
return newTemplate;
}
}
----------------------------------------------------------
An umple template contains a map for emittable strings
@umplesource StateMachine.ump 359
@umplesource Umple.ump 653
@umplesource Umple_Code.ump 1472
@umplesource Umple_Code_Trait.ump 377
@umplesource Test_Code.ump 18
@umplesource Trace.ump 23
@umplesource Structure.ump 18
@umplesource Template.ump 45
@umplesource DiagramMaster.ump 81
"];
"UmpleClass" -> "UmpleClassifier" [arrowhead="empty"; samehead="gen"];
// Class: Position
"Position" [ style=filled, fillcolor="#FFCCCC" shape=plaintext margin=0 label=<| UmpleModel |
| umpleFile : UmpleFile |
| distributeOn : Boolean |
| distributeForced : Boolean |
| distributed : Boolean |
| distributePattern : Integer |
| distributeTechnology : String |
| defaultPackage : String |
| generates : GenerateTarget[] |
| shouldGenerate : Boolean |
| glossary : Glossary |
| defaultNamespace : String |
| code : String |
| mainClass : UmpleClass |
| debugMode : Boolean |
| lastResult : ParseResult |
| generatedCode : Map<String,String> |
| analyzers : Map<String,Analyzer> |
| levelOffset : Coordinate |
| initialOffset : Coordinate |
| classSize : Coordinate |
| maxYLevels : int |
| extraCodes : CodeBlock[] |
| offsetFromEdge : Coordinate |
| reflexiveSegmentLength : int |
| linkedFiles : List<File> |
| parsingTime : Double |
| gTime1 : Double |
| gTime2 : Double |
| hashMap : Map<String,String> |
| traceType : String |
| tracer : TracerDirective |
>,
tooltip="class UmpleModel
* Class UmpleModel is the central class describing the system being compiled.
The model contains everything that was derived from an Umple file (.ump) when it was parsed such as
the classes, attributes, associations, state machines, methods, etc that were in it.
Put another way, when an Umple file (.ump) is parsed an Umple model is populated with everything that was parsed from that file.
Because of this it is absolutely critical to understand the model since it is basically the \"root\" of everything.
*
In Umple_Code.ump: Methods for manipulating the Model
---------------------------------------------------------------------------------------------
------------------------------------class start----------------------------------------------
---------------------------------------------------------------------------------------------
Copyright: All contributers to the Umple Project
This file is made available subject to the open source license found at:
http://umple.org/license
Mixset meta-model
Copyright: All contributers to the Umple Project
This file is made available subject to the open source license found at:
http://umple.org/license
Feature diagram meta-model
A FeatureDiagram stores information required to build a feature diagram in Umple
*************************************************************************************
************************************NEW CLASS****************************************
*************************************************************************************
Yellow for Classifiers, classes etc.
@umplesource Umple.ump 29
@umplesource UmpleVersion.ump 13
@umplesource Umple_Code.ump 18
@umplesource Umple_Code_Trait.ump 6
@umplesource Mixset.ump 12
@umplesource FeatureModel.ump 14
@umplesource Trace.ump 17
@umplesource UmpleInternalParser_CodeTrait.ump 7
@umplesource UmpleInternalParser_CodeMixset.ump 18
@umplesource DiagramMaster.ump 76
"];
"UmpleModel" -> "Runnable" [ arrowhead="empty"; samehead="gen"; style=dashed];
// Class: Filter
"Filter" [shape=plaintext margin=0 label=<| UmpleInternalParser |
| currentPackageName : String |
| redefinePackageName : String |
| packageNameUsed : Boolean |
| outputUmpleSource : Boolean |
| model : UmpleModel |
| parser : RuleBasedParser |
| lastParsedNameSpace : NameSpace |
| allowedMessages : Integer[] |
| ignoredMessages : Integer[] |
| disallowedMessages : Integer[] |
| expectedMessages : Integer[] |
| unparsedUmpleFiles : String[] |
| parsedUmpleFiles : String[] |
| shouldProcessAgain : Boolean |
| shouldProcessClassAgain : Boolean |
| unlinkedAssociationVariables : AssociationVariable[] |
| unlinkedAssociations : Association[] |
| positionToClassNameReference : Map<Position,String> |
| unanalyzedInvariants : Map<UmpleClassifier,List<Token>> |
| unlinkedExtends : Map<UmpleClassifier,List<String>> |
| unlinkedExtendsTokens : Map<UmpleClassifier,List<Token>> |
| unlinkedExtendsTokensInterface : Map<UmpleClassifier,List<Token>> |
| unlinkedInterfaceExtends : Map<UmpleClassifier,List<String>> |
| unlinkedKeysTokens : Map<UmpleClass,List<Token>> |
| unanalyzedInjectionTokens : Map<UmpleClassifier,List<Token>> |
| lastComments : Comment[] |
| lastattr : Attribute |
| lastassoc : AssociationVariable |
| lastassocPosition : Position |
| attributeAutouniqueImmutable : Map<Token,UmpleClass> |
| fixmlLastIntilialization : Map<Attribute,Token> |
| fixmlAttributeCount : Map<Attribute,Integer> |
| afixmlLastIntilialization : Map<Association,List<Token>> |
| afixmlAttributeCount : Map<Association,Integer> |
| compWalker : CompositeStructureDefinitionWalker |
| walker : TemplateDefinitionWalker |
| placeholderStateMachine : StateMachine |
| stateMachineNameToToken : Map<String,Token> |
| possiblyUnknownStates : Map<State,List<Token>> |
| stateNames : List<Token> |
| transitionNames : List<Token> |
| ignoredTransitions : List<Token> |
| innerMixsetTokens : List<Token> |
| traceFlagId : Integer |
| traceDirective : TraceDirective |
| traceAttr : AttributeTraceItem |
| tracedAssoc : AssociationTraceItem |
| mte : MethodTraceItem |
| tca : TraceCase |
| post : Postfix |
| parsedUmpfiles : Map<String,Boolean> |
>,
tooltip="class UmpleInternalParser
This is our internal parser implementation for the Umple language. It uses
a generic Parser that can read an external EBNF grammar file, and then populate
an abstract syntax tree.
The work of the UmpleInternalParser is
a) The grammar definition (defined externally in *.grammar files)
b) Analyzing the AST to populate an Umple meta model instance
c) Delegating to our code generator to produce the necessary artifacts (i.e. Java / PHP / Ruby code)
Please refer to UmpleInternalParser_Code.ump for implementation details.
*************************************************************************************
************************************NEW CLASS****************************************
*************************************************************************************
This is a mixin feature of Umple. The Content of following class will be added automatically to core parse.
*************************************************************************************
************************************NEW CLASS****************************************
*************************************************************************************
Internal invocation for internal umple parser in order to invoke walkers calls which
can instantiate the analysis if required
Internal invocation for internal umple parser in order to invoke walkers calls which
can instantiate the analysis if required
Copyright: All contributers to the Umple Project.
This file is made available subject to the open source license found at:
http://umple.org/license
This file analyzses require statement tokens to populate Requiregraph for Umple model.
Please refer to UmpleInternalParser.ump for more details.
Pink for core Umple classes for parsing and the model
@umplesource UmpleInternalParser.ump 26
@umplesource UmpleInternalParser_Code.ump 35
@umplesource UmpleInternalParser_CodeCore.ump 17
@umplesource UmpleInternalParser_CodeClass.ump 17
@umplesource UmpleInternalParser_CodeTrait.ump 24
@umplesource UmpleInternalParser_FIXML.ump 3
@umplesource UmpleInternalParser_CodeTrait_StateMachine.ump 21
@umplesource UmpleInternalParser_CodeConstraints.ump 17
@umplesource UmpleInternalParser_CodeStructure.ump 1594
@umplesource UmpleInternalParser_CodeTemplate.ump 824
@umplesource UmpleInternalParser_CodeStateMachine.ump 17
@umplesource UmpleInternalParser_CodeTrace.ump 17
@umplesource UmpleInternalParser_CodeTraceAttribute.ump 17
@umplesource UmpleInternalParser_CodeTraceStateMachine.ump 17
@umplesource UmpleInternalParser_CodeTraceAssociation.ump 17
@umplesource UmpleInternalParser_CodeTraceCase.ump 17
@umplesource UmpleInternalParser_CodeLayout.ump 17
@umplesource UmpleInternalParser_CodeUSE.ump 17
@umplesource UmpleInternalParser_CodeFilter.ump 17
@umplesource UmpleInternalParser_CodeEnumeration.ump 9
@umplesource UmpleInternalParser_CodeMixset.ump 53
@umplesource UmpleInternalParser_CodeRequireStatement.ump 12
@umplesource UmpleInternalParser_CodeTest.ump 9
@umplesource DiagramMaster.ump 58
"];
"UmpleInternalParser" -> "Parser" [arrowhead="empty"; samehead="gen"];
"UmpleParser" [style=filled, fillcolor="#FFCCCC"];
"UmpleInternalParser" -> "UmpleParser" [ arrowhead="empty"; samehead="gen"; style=dashed];
// Class: CompositeStructureTokenAnalyzer
"CompositeStructureTokenAnalyzer" [shape=plaintext margin=0 label=<