| Action |
A quickly-executed block of code that is run upon entry or exit from a state
NEW CLASS****************************************
|
| ActiveDirectionHandler |
|
| ActiveDirectionHandlerBody |
|
| ActiveMethod |
|
| Activity |
Some code to execute for an extended period while in a state
This code is found after they keyword 'do' in Umple
The code is executed in a separate threat, and can be terminated by
an outgoing transition.
|
| AlloyGenerator |
|
| AnalysisParserTask |
Abstraction for task parser to be analyzed.
|
| AnonymousFunction |
|
| Appender |
|
| ArgumentTokenizer |
BEGIN_COPYRIGHT_BLOCK
Copyright (c) 2001-2010, JavaPLT group at Rice University (drjava@rice.edu)
All rights reserved.
|
| Association |
Represents an association, typically between two Umple classes (1-1, 1-*, *-1, etc).
|
| AssociationClass |
A combination of Class and Association (as defined in UML)
An AssociationClass is a full-fledged class, but at the same time
It associates two other classes that would otherwise have a many-many
relationship.
|
| AssociationEnd |
An association end represents one logical end of an association
See also AssociationVariable
TODO: Code smell referenceToClassName is a duplication, can access via the association
Create a derived attribute otherend (the other AssociationEnd)
In Umple_Code.ump: Methods for computing compound properties
|
| AssociationTraceItem |
|
| AssociationVariable |
An association variable represents one of the variables used to represent
an association.
|
| Attribute |
Represents an attribute.
|
| AttributeElement |
|
| AttributeTraceItem |
An element of a trace directive that indicates to trace one or more attributes
|
| BasicConstraint |
|
| BindingDescriptor |
|
| ClassDependencyNode |
|
| ClassDependencyTree |
|
| ClassMetrics |
|
| ClassPattern |
A pattern object is used to persist Patentable information for a class elemnt such as
abstract, delegate, immutable, etc.
|
| ClassStatsVisitor |
Used to extract the required metrics information for the states of a given class.
|
| CodeAnalysisGenerator |
|
| CodeBlock |
A block of code in an arbitrary language to be injected into generated code
Please update the method 'public CodeBlock(CodeBlock another)' if you add new attributes.
|
| CodeBlockElement |
Scriplet segment in a template
|
| CodeCompiler |
|
| CodeGeneratorWithSubptions |
Default implementation for generators with suboptions
|
| CodeInjection |
A block of code that can be injected into one or more methods, constructor, etc.
|
| CodeMetrics |
|
| Comment |
Represents a comment, such as those found around classes, methods, attributes and associations.
|
| CommentElement |
Comment segment for a template contents
|
| CompileDate |
|
| ComponentDescriptor |
|
| CompositeStateTableRow |
|
| CompositeStateWrapper |
Container containing multiple concurrent states.
|
| CompositeStructureDefinitionWalker |
Walk through definition tree while analyzing template tokens
|
| CompositeStructureTokenAnalyzer |
Used as a helper class to analyze tokens in a given component
|
| CompositeTransitionWrapper |
Container containing multiple transitions of the same name
|
| CompoundFeatureNode |
A compund feature has multiple of features (like xor , or and other that have multiplicity.)
|
| Condition |
Used to associated condition patern for an umple elemnt.
|
| ConditionRhs |
|
| Constant |
Represents a constant.
|
| ConstraintAssociation |
ConstraintAttributes encapsulate the association for the constraint, this will be a leaf on the constraint tree.
|
| ConstraintAttribute |
ConstraintAttributes encapsulate the attribute for the constraint, this will be a leaf on the constraint tree
|
| ConstraintLiteral |
ConstraintLiterals encapulate raw data literals, such as strings, numbers and booleans, that do not have an model variable associated.
|
| ConstraintMethodParameter |
ConstraintMethodParameters are there for Preconditions and Postconditions, they encapsulate the MethodParameter that the constraint is refering to
This will be a leaf on the constraint tree.
|
| ConstraintNamed |
This super class contains all subclasses that have elements with names
|
| ConstraintNumberLiteral |
Number literals are the special case of literals, where the value they contained is garanteed to be a number.
|
| ConstraintOperator |
ConstraintOperators encapsulate the branching of the constraint tree, where the branches occur at the operators, for example
[a<3&&b!="loved"]
the basic structure will look like
ConstraintOperator(&&)
/ \
ConstraintOperator(<) ConstraintOperator(!=)
/ \ / \
ConstraintAttribute(a) ConstraintNumberLiteral(3) ConstraintAttribute(b) ConstraintLiteral("loved")
With the extra complication that ConstraintTrees parent everything that are not ConstraintLiterals
|
| ConstraintPort |
ConstraintPort encapsulate the statemachine data in a port watch expression
|
| ConstraintState |
ConstraintStates encapsulate the state data in a statemachine expression such as [sm is in state st], this is a leaf in the constraint tree/
|
| ConstraintStateMachine |
ConstraintStateMachines encapsulate the statemachine data in a statemachine expression such as [sm is in state st], this is a leaf in the constraint tree.
|
| ConstraintTree |
ConstraintTrees are a redundant class that are necessary because of lone constraints, i.e.
|
| ConstraintUnassignedName |
ConstraintUnassignedNames are names that were not recognized by the analysis, for example ConstraintMethodParameters are originally ConstraintUnassignedNames,
but are caught when they are added to the Precondition or Postcondition and a ConstraintMethodParameter is added instead of the ConstraintUnassignedName.
|
| ConstraintVariable |
ConstraintVariables encapsulate that data of one element in a ConstraintTree, making up the nodes of that tree.
|
| Coordinate |
A Coordinate is used in the layout of classes
It represents the shape of a class box in a diagram
|
| CountClass |
end of class ClassMetrics
|
| CountLines |
This class is used like a structure to help keep values about lines
|
| CountSM |
END OF CLASS StateMachineMetrics
CountSM class used to calculate State Machine Metrics.
|
| Couple |
An open-close pair, such as open curly brackets and close curly brackets
Used to identify block start and end while parsing
|
| CppMethodTemplateFormatter |
|
| DeferredCall |
|
| DeferredFunction |
|
| Depend |
A depend relationship indicates a package on which this class depends
|
| DivElement |
|
| EcoreAttribute |
|
| EcoreClass |
|
| EcoreClassElement |
|
| EcoreDataType |
|
| EcoreEnum |
|
| EcoreEnumItem |
|
| EcoreGenerator |
|
| EcoreGenericNode |
|
| EcoreGenericType |
|
| EcoreGenericTypeArgument |
|
| EcoreGenericTypeNode |
|
| EcoreGenModel |
|
| EcoreImportHandler |
Parse ECore by extend SAX handler callbacks
|
| EcorePackage |
|
| EcoreReference |
|
| EcoreTypeParameter |
|
| Element |
|
| EmitResponse |
|
| Event |
NEW CLASS****************************************
|
| EventListRow |
A row in the list-style output
|
| EventModifier |
This is used to remove an event or a transition.
|
| EventSequenceCell |
Represents a cell in a row in the Event Sequence table.
|
| EventSequenceGenerator |
|
| EventSequenceHeaderCell |
Represents a cell in a row in the first row of a Event Sequence table.
|
| EventSequenceList |
This is the list-style view for the event sequence.
|
| EventSequencer |
|
| EventSequenceTable |
The grid-type view of the event sequence, with the possible states as rows
and the sequence of events as columns.
|
| EventSequenceTableHeaderRow |
Represents the header row of a Event Sequence table.
|
| EventSequenceTableRow |
Represents a row in the Event Sequence table.
|
| EventSequenceTemplate |
Contains the templates for both the event sequence UI types
|
| EventSequenceWalkTracker |
|
| EventWrapper |
Allows mapping from events to the various transitions.
|
| ExpressionElement |
Expression segment in a template
|
| ExtendStateByStateMachine |
This is used to extend a state with a state machine.
|
| ExternalGrammarGenerator |
|
| ExtraCode |
|
| FeatureLeaf |
A FeatureLeaf contains a full mixset or a full file.
|
| FeatureLink |
A FeatureLink connects a source feature to target feature(s) in the feature diagram.
|
| FeatureModel |
|
| FeatureNode |
A Feature model consists of some FeatureNodels, which can be leaf nodes or fragmentFeature nodes.
|
| Filter |
Fragment source file: Umple_Code.ump
Line : 4932
A Diagram represents a subset of the available model and is used
to help isolate certain aspects of the system.
|
| Format |
|
| FragmentFeatureLeaf |
A FragmentFeatureLeaf consists of one or more mixset fragments.
|
| GeneralTemplateParameter |
This class is used to specify parameters for traits.
|
| GeneralTPApplied |
This class is used to assign parameters in classes and traits.
|
| GeneratedClass |
Represents a class that is generated from an Umple class, such as a Java or Cpp class.
|
| GeneratedElement |
TODO: Code smell: This duplicates the structure of the class from UmpleClass
This is a problem for model-to-model transformations
Should be abolished
|
| GenerateTarget |
Represents the generation target, such as what the generated output language will be.
|
| GeneratorHelper |
|
| Graph |
|
| Guard |
A boolean condition that is checked when an event method is called
If the result is true the transition may be taken
NEW CLASS****************************************
|
| GvClassDiagramGenerator |
|
| GvClassTraitDiagramGenerator |
|
| GvEntityRelationshipDiagramGenerator |
|
| GvFeatureDiagramGenerator |
|
| GvStateDiagramGenerator |
|
| Hierarchy |
Used to persist hirarchy information for given elemnts (owner, and children)
|
| HtmlDocument |
|
| HtmlElement |
|
| IAttributesConstants |
|
| ImportAction |
|
| ImportStateMachine |
|
| ImportStateMachineElement |
|
| ImportStateMachineState |
|
| ImportTransition |
|
| IncludeTemplateElement |
Include segment in a template
|
| ITagsConstants |
Generator HTML utils are designed to proivde a standlone HTML elements generation using Umple.
|
| JavaGenerator |
|
| JavaMethodTemplateFormatter |
|
| JsonGenerator |
|
| JsonMixedGenerator |
|
| Key |
A key in a class is a set of attributes associations used to uniquely identify an object
|
| Level |
|
| LLOCMetricVisitor |
LLOC metrics vistor.
|
| LogConfiguration |
|
| LoggerLevelToAppender |
|
| LogLevel |
|
| McCabeMetricVisitor |
McCabe = Edges - Nodes + 2 * ExitNodes
McCabe = Edges - Nodes + ExitNodes
McCabe = Number of logical points + 1
|
| MeasurmentObject |
Designed to be implemnted ny metric classes.
|
| MessageComponent |
|
| MessageConstraint |
|
| MessageField |
|
| MessageHandler |
|
| MessageStructure |
pririoriy constraint
|
| Method |
A method in an Umple class or interface
Umple Methods are coded by the programmer in the language(s) of their choice
This is for cloning
Note: This code doesn't cover deep cloning.
|
| MethodBody |
The contents of a method, such as the code within it.
|
| MethodParameter |
Represents a parameter in a method and its various forms.
|
| MethodTemplateSignature |
|
| MethodTraceItem |
|
| Mixset |
A mixset is a block of code that may or may not be included by a use statement
It consists of one or more fragments that are encountered anywhere in the Umple source
including in other mixsets
|
| MixsetFragment |
Each mixset statement creates a MixSetFragment
|
| MixsetInMethod |
This class keeps references to mixsets which are iside methods
|
| MixsetOrFile |
A MixsetOrFile is an umple entity that is subject to require logic
|
| ModelConstraint |
|
| ModelConstraintAssociation |
|
| ModelConstraintAttributeFromClass |
|
| ModelConstraintAttributeFromName |
|
| ModelConstraintResult |
|
| ModelConstraintSubClass |
|
| ModelConstraintSuperClass |
|
| Monitor |
|
| Multiplicity |
A multplicity constrains the number of linked objects at one end of an
association
TODO: extract derived attributes from Umple_Code.ump (getLowerBound etc.)
In Umple_Code.ump: Methods for querying various propertiies of a Multiplicit
|
| MultiplicityFeatureConnectingOpType |
MultiplicityFeatureConnectingOpType is a special type of FeatureLink in which there are min and max multiplicity.
|
| NameSpace |
added for issue 1315 warning 31
|
| NothingGenerator |
|
| NuSMVGenerator |
|
| NuSMVOptimizerGenerator |
|
| ObjectElement |
object element is any element with type value and name, such as attribute or Umple element.
|
| Package |
A root class elemnt.
|
| PairDescriptor |
|
| PapyrusGenerator |
|
| PapyrusImportHandler |
Parse Papyrus
|
| ParagraphElement |
|
| Parser |
Parses an Umple file (.ump) based on grammar rules.
|
| PhpGenerator |
|
| PlainRequirementsDocGenerator |
|
| Point |
class GeneratedInterface
{
isA GeneratedElement;
//code = null;
-> 1 UmpleModel model;
0..1 -> 1 UmpleInterface uInterface;
}
A point in cartesian coordinates, used in representing the layout of a
diagram in Umple
|
| Port |
component
|
| PortBinding |
|
| PortBindingInformation |
|
| PortConstraint |
|
| PortFunction |
|
| Postcondition |
The Preconditions are constraints on methods, throughing an exception if the constraint is not sastisfied after the method has computed.
|
| Postfix |
|
| Precondition |
The Preconditions are constraints on methods, restricting the method so that it does not process if the constraint is not satisfied.
|
| Primitive |
|
| Protocol |
|
| PythonGenerator |
|
| Record |
class TraceRecord
{
Boolean recordOnly = false;
-> * UmpleVariable;
-> * Attribute;
1 -> * Record;
}
|
| Requirement |
Represents a requirement, such as those found around classes, methods, attributes and associations.
|
| ReqVisitor |
|
| RTCppGenerator |
|
| RubyGenerator |
|
| Rule |
Represents a grammar rule, which has a name and contains definitions that describe it.
|
| RuleInstance |
Data captured during parsing when a certain rule matches
|
| RulePart |
Part of a grammar rule
|
| RulePartValue |
|
| Scope |
Local variables
|
| ScriptElement |
|
| ScxmlGenerator |
|
| ScxmlImportHandler |
Parse SCXML by extend SAX handler callbacks
|
| SimpleMetricsGenerator |
|
| SimulateGenerator |
|
| SqlGenerator |
|
| State |
One of the values in which a state machine can be at any given point in time
NEW CLASS****************************************
|
| StateComparator |
|
| StateEventEntry |
Cell entries for state-event tables
|
| StateMachine |
An entity in a running program that can have a set of values (states) and which
changes values by taking transitions in response to various events.
|
| StateMachineGraph |
|
| StateMachineMetrics |
|
| StateMachineModifier |
|
| StateMachineStatsVisitor |
Used to extract the required metrics information for the statemachines of a given class.
|
| StateMachineTemplateSignature |
|
| StateMachineTraceItem |
|
| StateModifier |
This is used to remove and rename a state.
|
| StateStateEntry |
Cell entries for state-state tables
|
| StateTable |
|
| StateTableCell |
Cell in a state table containing the resulting state or the event that results in transition
|
| StateTableRow |
Row in a state-state table and state-event table
Also iterated through as columns in a state-state-table
|
| StateTablesGenerator |
|
| StateWrapper |
A simple wrapper over a State machine's states that allows keeping track
of the parent state of the wrapped state, and all events that will cause
a transition out of the wrapped state.
|
| StructureDiagramGenerator |
|
| StyleElement |
|
| SuperCodeGenerator |
|
| SuperGvGenerator |
|
| TableElement |
|
| TemplateAttributeParser |
Parse existing attributes in a template
|
| TemplateDefinitionWalker |
Walk through definition tree while analyzing template tokens
|
| TemplateElement |
A template element represents template contents to be built.
|
| TemplateField |
A template filed reprsents a field with a value for emitting purposes
|
| TemplateMethod |
Method rpesentations in a template
|
| TemplateMethodBlock |
|
| TemplateName |
|
| TemplateTokenAnalyzer |
Used as a helper class to analyze tokens in a given template
|
| TestAction |
test action statements
|
| TestGenerator |
|
| TestInit |
initialization statements in test that holds
identifier objectname (parameters);
|
| TestParameter |
|
| TestSequence |
|
| TextContents |
|
| TextElement |
|
| TextUmlGenerator |
|
| TimerConstraint |
|
| TokenTree |
This class used to represent the binary tree of require-statement argument
Ex: require [A and B or C] will be formed as:
...
|
| TraceCase |
Future work - initial implementation is done
A group of trace directives that can be switched on or off by other
trace directives
|
| TraceCondition |
Discarded metamodel
|
| TraceConstraint |
TraceConstraint objects ensure that the attribute being traced will be treated as a parameter and not a member variable
|
| TraceDirective |
----- Trace Directive MetaModel
A statement found in Umple that directs code to be generated
to trace a model element and generate output using some tracing tool
|
| TraceItemUtil |
Util class that has common method called from different trace items
|
| TraceMessageSwitch |
|
| TracerArgument |
|
| TracerDirective |
----- Tracer Directive MetaModel
A statement found in Umple that directs tracing technology
to be used in generted code
|
| TraceRecord |
|
| Transition |
Specifies, within a state, what happens with a certain event (method call) occurs
Normally the state machine will go to a new state after executing various actions and
activities.
|
| Trigger |
|
| Uigu2Generator |
|
| UmletDiagram |
|
| UmletElement |
|
| UmletGenerator |
|
| UmpleAnalyzerGeneratorHandler |
This is the AnalyzerGeneratorHandler for the Umple language
This handler constructs Analyzers by name by using reflection
in the `cruise.umple.analysis` namespace
|
| UmpleAnnotaiveToCompositionGenerator |
|
| UmpleAssertion |
The assertion within the method or class.
|
| UmpleClass |
An UmpleClass can contain attributes, associations, state machines and methods.
|
| UmpleClassifier |
Represents an Umple classifier: a Class or Interface
|
| UmpleElement |
An UmpleElement is one of the top-level items found in an Umple model
Currently it has one subclass, UmpleClassifier
|
| UmpleEnumeration |
Represents an enumeration
|
| UmpleFile |
This class already exists in the util subdirectory
It is used for the main file, and there is code
to add linkedfiles.
|
| UmpleGenerator |
|
| UmpleImportAssociation |
|
| UmpleImportAttribute |
|
| UmpleImportClass |
|
| UmpleImportConstants |
|
| UmpleImportElement |
Defines import prototype for package, class, interface
and associations
|
| UmpleImportGeneralization |
|
| UmpleImportHandler |
|
| UmpleImportHandlerFactory |
|
| UmpleImportModel |
integration of all importElements as a model
|
| UmpleImportPackage |
|
| UmpleImportType |
ImportType is a "enumeration" of information for what type of
file was imported.
|
| UmpleInterface |
Represents a interface.
|
| UmpleInternalParser |
This is our internal parser implementation for the Umple language.
|
| UmpleLinkedFileHandler |
This is the LinkedFileHandler for the Umple language.
|
| UmpleModel |
Class UmpleModel is the central class describing the system being compiled.
|
| UmpleModelHelper |
A common util for the implemented Measurment objects (@see MeasurmentObject).
|
| UmpleModelVisitor |
It is designed to visit different types of umple elemnts so it can process and understand
the defined walkers (@see IWalker).
|
| UmpleModelWalker |
A generic walker that is designed to parse different types of umple elements.
|
| UmpleObject |
UmpleObject is used to initialize classes
|
| UmpleParserFactory |
|
| UmpleSelfGenerator |
|
| UmpleTemplate |
|
| UmpleTestCase |
Test Case at the Class level .
|
| UmpleTrait |
An UmpleTrait can contain attributes, associations, state machines and methods.
|
| UmpleVariable |
Superclass for tracking member variables in all target languages
TODO: Code smell because we have both an association variable and also an association
This class should go and instead AssociationEnd should be the member variable
|
| UmpleXtextParser |
|
| UncaughtException |
|
| UniqueIdentifier |
|
| USEGenerator |
|
| UserCode |
It is used to track user code when processing objects information
|
| UseStatementParserAction |
This is the ParserAction to handle 'use' tokens in Umple.
|
| Utils |
Helpr class to handle the process of emiitting the code to its eqivalent in JET based
on the existing template elements and their contents, expressions, etc.
|
| VariableElement |
|
| VioletAssociation |
|
| VioletClass |
|
| VioletDiagram |
|
| VioletGenerator |
|
| XmiGenerator |
|
| XORFeatureConnectingOpType |
XORFeatureConnectingOpType is a special type of FeatureLink in which lower & upper bounds of the set are limited to 1 (i.e.
|
| XtextGenerator |
|
| YumlGenerator |
|