All Classes
| Class | Description |
|---|---|
| AbbreviationMap<V> |
A map whose keys are strings; when a key/value pair is added to the map, the longest unique abbreviations of that
key are added as well, and associated with the value.
|
| AbstractGenBody | |
| AbstractGenConstraint | |
| AbstractServer |
This file contains material derived from
"Object Oriented Software Engineering" by Lethbridge and Laganiere
and is issued under the open-source
license found at www.lloseng.com
This is a framework for a server that can read and write characters
|
| Action |
A quickly-executed block of code that is run upon entry or exit from a state
NEW CLASS****************************************
|
| ActiveDirectionHandler | |
| ActiveDirectionHandler.DirectionHandler | |
| ActiveDirectionHandlerBody | |
| ActiveDirectionHandlerBody.BodyType | |
| ActiveGenMethd | |
| ActiveMemberInitializer | |
| ActiveMethod | |
| ActiveMethod.ActiveType | |
| 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 | |
| AlloyModel | |
| AlloyObject | |
| AnalysisErrorStub |
log analysis errors
|
| AnalysisParserTask |
Abstraction for task parser to be analyzed.
|
| AnalysisStub |
Analyze call
|
| Analyzer |
This is the base class for all Analyzers used in the GrammarAnalyzer.
|
| AnalyzerGeneratorHandler |
This is a handler/delegate class that handles construction of Analyzer classes
at runtime.
|
| AndOpAnalyzer | |
| AnonymousFunction | |
| Appender | |
| ArgumentAcceptingOptionSpec<V> |
Specification of an option that accepts an argument.
|
| ArgumentsRetrieval | |
| ArgumentTokenizer |
BEGIN_COPYRIGHT_BLOCK
Copyright (c) 2001-2010, JavaPLT group at Rice University (drjava@rice.edu)
All rights reserved.
|
| ArithmeticCallAnalyzer | |
| ArithmeticCallOperatorAnalyzer | |
| Assign | |
| AssignConstraint | |
| Association |
Represents an association, typically between two Umple classes (1-1, 1-*, *-1, etc).
|
| Association.Source | |
| 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
|
| AssociationExprAllAnalyzer | |
| AssociationExprAnalyzer | |
| AssociationExprEqualsOpAnalyzer | |
| AssociationExprFirstOpAnalyzer | |
| AssociationExprGreaterOpAnalyzer | |
| AssociationExprLessOpAnalyzer | |
| AssociationExprMoreOpAnalyzer | |
| AssociationExprNotequalsOpAnalyzer | |
| AssociationExprSmallerOpAnalyzer | |
| AssociationFact | |
| AssociationLiteralAnalyzer | |
| AssociationTraceItem | |
| AssociationVariable |
An association variable represents one of the variables used to represent
an association.
|
| Attribute |
Represents an attribute.
|
| Attribute.Source | |
| AttributeElement | |
| AttributeTraceItem |
An element of a trace directive that indicates to trace one or more attributes
|
| BalancedRule |
Balanced rules ensure that braces are balanced, that is, that the corresponding brace is matched.
|
| BasicConstraint | |
| BasicExpression | |
| BasicExpression.Operator | |
| BidirectionFact | |
| BindingDescriptor | |
| BoolExprAnalyzer | |
| BoolLiteralAnalyzer | |
| BuiltinHelpFormatter |
A help formatter that allows configuration of overall row width and column separator width.
|
| CaseExpression | |
| CaseStatement | |
| ChainRule |
name : [[rule]] [[rule]]*
Similar to the Choice rule, except all sub rules must be successful when parsing(similar to an 'and' being performed on a hypotheical "isSuccess" for each rule)
Because of the possibility for subrules to be optional, this Rule type must support back tracking, where after a failure, the rule will remove tokens from the growing return token when it needs to reconsider a sub rule as being parsable.
|
| ChoiceRule |
name : [[rule]] ( | [[rule]] )*
The basic parsing rule.
|
| ClassDependencyNode | |
| ClassDependencyTree | |
| Classes | |
| 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 | |
| CodeGenerator |
Allows independent code generation tools
Different generators will do different things regarding where the files are put, etc.
|
| CodeGeneratorWithSubptions |
Default implementation for generators with suboptions
|
| CodeInjection |
A block of code that can be injected into one or more methods, constructor, etc.
|
| CodeMetrics | |
| CodeTranslator | |
| ColumnEntry | |
| Command | |
| Comment |
Represents a comment, such as those found around classes, methods, attributes and associations.
|
| CommentElement |
Comment segment for a template contents
|
| CommonConstants |
The common constants for code generation
|
| CommonTypesConstants |
The common return type constants
|
| CompileDate | |
| ComponentDescriptor | |
| CompositeStateTableRow | |
| CompositeStateWrapper |
Container containing multiple concurrent states.
|
| CompositeStructure | |
| 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 | |
| ConnectionToClient | |
| 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
|
| ConstraintBodyAnalyzer | |
| 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.
|
| ConstraintNameAnalyzer | |
| ConstraintNamed |
This super class contains all subclasses that have elements with names
|
| ConstraintNameIndexAnalyzer | |
| ConstraintNameNameAnalyzer | |
| ConstraintNameNewAnalyzer | |
| 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
|
| ConstraintParameterAnalyzer | |
| ConstraintParameterListAnalyzer | |
| ConstraintParameterListCommaAnalyzer | |
| ConstraintParameterNumberAnalyzer | |
| ConstraintPort |
ConstraintPort encapsulate the statemachine data in a port watch expression
|
| ConstraintScopeOperatorAnalyzer | |
| 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.
|
| ConstraintTokenAnalyzer | |
| 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.
|
| Content |
Data for the user manual taken from one of the files in
build/reference
|
| ContentParser |
Specialist parser for the Umple user manual
Parses files in build/reference/*
|
| ContentsDescriptor | |
| Coordinate |
A Coordinate is used in the layout of classes
It represents the shape of a class box in a diagram
|
| Coordinate.Status | |
| CountClass |
end of class ClassMetrics
|
| CounterExampleColumn | |
| CounterExampleTable | |
| 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
|
| CPPCommonConstants |
The common constants for C++ code generation
|
| CPPContentsPointsHandler | |
| CppMethodTemplateFormatter | |
| CppPoliciesProcessor | |
| CppStatemachinePointsHandler | |
| CppTestsPointsHandler | |
| CPPTypesConstants |
The common return type constants
|
| CTLExpression | |
| CTLExpression.CtlOperator | |
| CTLSpecification | |
| DateConverter |
Converts values to
Dates using a DateFormat object. |
| DeferredCall | |
| DeferredFunction | |
| DeferredFunction.DeferredCallType | |
| DefineBody | |
| DefineDeclaration | |
| DeleteAction | |
| DeleteAssociationAction | |
| DeleteGeneralizationAction | |
| DeleteTransitionAction | |
| Depend |
A depend relationship indicates a package on which this class depends
|
| DivElement | |
| Documenter |
The tool to create the html text of the Umple user manual
|
| DocumenterMain | |
| DocumenterMain.UmpleExceptionHandler | |
| DocumenterMain.UmpleSourceData | |
| DynamicClassPathLoader | |
| EcoreAttribute | |
| EcoreClass | |
| EcoreClassElement | |
| EcoreDataType | |
| EcoreEnum | |
| EcoreEnumItem | |
| EcoreGenerator | |
| EcoreGenericNode | |
| EcoreGenericType | |
| EcoreGenericTypeArgument | |
| EcoreGenericTypeNode | |
| EcoreGenModel | |
| EcoreImportHandler |
Parse ECore by extend SAX handler callbacks
|
| EcorePackage | |
| EcoreReference | |
| EcoreTypeParameter | |
| EditAction | |
| EditAssociationAction | |
| Element | |
| EmitResponse | |
| EqualsOpAnalyzer | |
| ErrorMessage |
Represents an error message, typically used with parsing.
|
| ErrorType |
Represents an error type, which contains an error code, the severity of the error, etc.
|
| ErrorTypeSingleton |
Lists all the errors in the system
|
| 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.
|
| ExceptionDumper | |
| ExplorationResult | |
| ExpressionElement |
Expression segment in a template
|
| ExtendStateByStateMachine |
This is used to extend a state with a state machine.
|
| ExternalGrammarGenerator | |
| ExtraCode | |
| Fact | |
| 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.
|
| FeatureLink.FeatureConnectingOpType | |
| 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.
|
| FixmlPointsHandler | |
| Format | |
| FragmentFeatureLeaf |
A FragmentFeatureLeaf consists of one or more mixset fragments.
|
| Function | |
| GenActiveField | |
| GenAspectableReturnBody | |
| GenAssociation |
List handlers (vector vs set); cpp-specific
Helper methods for many relations
Constructor roles
Setter roles
Delete roles
Add roles
|
| GenAssociationEnd | |
| GenBaseConstructorMethod | |
| GenBody | |
| GenClass |
Copyright (c) 2017 Ahmed M.Orabi, Mahmoud M.Orabi.
|
| GenComment | |
| GenComplexPort | |
| GenConnectEntry | |
| GenConstraint | |
| GenConstraintCondition | |
| GenConstraintOperators | |
| GenConstraintVariable | |
| GenConstructor | |
| GenConstructorMethod | |
| GenDeleteMethod | |
| GenDepend |
class GenDepend{
String includeNamespace(){
GenClass genClass= getGenClass();
if(genClass!= null){
return genClass.includeNamespace();
}
return getNamespace();
}
namespace= {includeNamespace()};
}
|
| GenDestructorMethod | |
| GenEndpointPropagationBody |
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Composite-structure-specific
|
| GenEnum | |
| GenEnumEntry | |
| GenEqualityMethod | |
| 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.
|
| GenerationArgumentDescriptor | |
| GenerationCallback | |
| GenerationCallback.GenerationArgument | |
| GenerationCallback.GenerationArguments | |
| GenerationCallback.GenerationBaseElement | |
| GenerationCallback.GenerationCallbackCondition | |
| GenerationCallback.GenerationCallbackProcedure | |
| GenerationCallback.GenerationCallbackProcedures | |
| GenerationCallback.GenerationCallbackVariable | |
| GenerationCallback.GenerationElementParameter | |
| GenerationCallback.GenerationLoopElement | |
| GenerationCallback.GenerationLoopPath | |
| GenerationCallback.GenerationProcedureParameter | |
| GenerationCallback.GenerationRegistry | |
| GenerationCallback.GenerationStringSegment | |
| GenerationCallback.IGenerationArguments | |
| GenerationCallback.IGenerationArgumentsObject | |
| GenerationCallback.IGenerationArgumentsObjectDescriptor | |
| GenerationCallback.InvokePoint | |
| GenerationCallback.StubPoint | |
| GenerationCallback.WatchedObjectValue | |
| GenerationGroupDefinition | |
| GenerationLogger | |
| GenerationLoopAnnotation | |
| GenerationLoopAnnotation.GenerationLoopAnnotationFilter | |
| GenerationPoint | |
| GenerationPoints | |
| GenerationPolicyRegistry | |
| GenerationPolicyRegistryPriorities | |
| GenerationTemplate |
Statemachine-specific
STL-specific
Test-specifid
Umple-specific
|
| GenerationTemplateDelegator | |
| GenerationUtil | |
| GenerationValueAnnotation | |
| GenerationValueGetterDelegator | |
| Generator | |
| GeneratorHelper | |
| GenExprAnalyzer | |
| GenField | |
| GenFieldGeneric | |
| GenFieldInitializer |
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CPP-specfific
|
| GenGroup | |
| GenHeaderDepend | |
| GenHierarchyFact | |
| GenIncompleteDefinition | |
| GenInterface | |
| GenInternalCopyMethod | |
| GenMethod | |
| GenMethodParameter | |
| GenPackage |
Copyright (c) 2017 Ahmed M.Orabi, Mahmoud M.Orabi.
|
| GenParentMethodParameter | |
| GenPort | |
| GenPriorities | |
| GenRequirement | |
| GenSpecializedDefinition |
/////////////////////////////////////////////
|
| GenState | |
| GenStatemachine | |
| GenStreamMethod | |
| GenStruct | |
| Glossary | |
| GrammarAnalyzer |
The grammar analayzer deals with first analyzing the root token of the grammar files, and constructing the rule graph for the grammar
then it has a execute function which will use the rule graph in the parsing of the umple file.
|
| Graph | |
| GreaterOpAnalyzer | |
| Group |
A section of the Umple user manual
Defined in the build/references/order.group
|
| 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****************************************
|
| GuardAnalyzer | |
| GvClassDiagramGenerator | |
| GvClassTraitDiagramGenerator | |
| GvEntityRelationshipDiagramGenerator | |
| GvFeatureDiagramGenerator | |
| GvStateDiagramGenerator | |
| HelpFormatter |
Represents objects charged with taking a set of option descriptions and producing some help text from them.
|
| Hierarchy |
Used to persist hirarchy information for given elemnts (owner, and children)
|
| HtmlDocument | |
| HtmlElement | |
| IAnalysisWalker |
Walk through template tree while analyzing template tokens
Walk through template tree while analyzing template tokens
|
| IAttributesConstants | |
| ICppDefinitions | |
| ICppStatemachinesDefinitions | |
| IGenerationCommonConstants | |
| IGenerationDefinitions | |
| IGenerationPointPriorityConstants | |
| IGenerationTemplateRegistry | |
| IGenerationValueGetter | |
| IHtmlElement | |
| ILang |
TODO: These classes - should be refactored out
|
| IModelingConstants | |
| IModelingElementDefinitions | |
| ImportAction | |
| ImportStateMachine | |
| ImportStateMachineElement | |
| ImportStateMachineState | |
| ImportTransition | |
| IncludeTemplateElement |
Include segment in a template
|
| InetAddressConverter |
Converts values to
InetAddress using getByName. |
| InitAssign | |
| InitConstraint | |
| InvarConstraint | |
| InvarExpression | |
| InvarExpression.InvarOperator | |
| InvariantAnalyzer | |
| IPoliciesProcessor | |
| IsInOpAnalyzer | |
| IsNotInOpAnalyzer | |
| ISTLConstants |
The common STL return type constants
|
| IStructureConstants | |
| ITagsConstants |
Generator HTML utils are designed to proivde a standlone HTML elements generation using Umple.
|
| IVarDeclaration | |
| IWalker |
User can define their own walker that receives an UmpleModelVisitor to visit a given element contents
|
| JavaClassGenerator | |
| JavaDistributedTemplates | |
| JavaGenerator | |
| JavaInterfaceGenerator | |
| JavaMethodTemplateFormatter | |
| JavaObjectFactoryClassGenerator | |
| JavaObjectFactoryInterfaceGenerator | |
| JavaProxyGenerator | |
| JavaSpecGenerator | |
| Json | |
| JsonGenerator | |
| JsonMixedGenerator | |
| JsonParser | |
| Key |
A key in a class is a set of attributes associations used to uniquely identify an object
|
| KeyValuePair |
A simple string key/string value pair.
|
| Language | |
| LessOpAnalyzer | |
| Level | |
| LinkedFileHandler |
This is a handler/delegate class that handles linked files supplied at
compile time.
|
| LinkingOpBodyAnalyzer | |
| LLOCMetricVisitor |
LLOC metrics vistor.
|
| LogConfiguration | |
| LoggerLevelToAppender | |
| LogLevel | |
| LoneBooleanAnalyzer | |
| LoopProcessorAnnotation | |
| LoopProcessorAnnotation.LoopAspectConstants | |
| LoopProcessorAnnotation.LoopProcessorAnnotations | |
| ManualExample | |
| McCabeMetricVisitor |
McCabe = Edges - Nodes + 2 * ExitNodes
McCabe = Edges - Nodes + ExitNodes
McCabe = Number of logical points + 1
|
| MeasurmentObject |
Designed to be implemnted ny metric classes.
|
| MemberInitializer | |
| MessageComponent | |
| MessageConstraint | |
| MessageField | |
| MessageHandler | |
| MessageHandler.CommunicationType | |
| 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.
|
| Method.Source | |
| MethodBody |
The contents of a method, such as the code within it.
|
| MethodDescriptor | |
| MethodParameter |
Represents a parameter in a method and its various forms.
|
| MethodTemplateFormatter | |
| MethodTemplateSignature | |
| MethodTraceItem | |
| MetricsCollector | |
| 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 | |
| ModelConstraintBodyAnalyzer | |
| ModelConstraintResult | |
| ModelConstraintSubClass | |
| ModelConstraintSuperClass | |
| ModelExprAnalyzer | |
| ModelingAssociationsGenerationPointsHandler | |
| ModelingBaseGenerationPointsHandler | |
| ModelLinkingOpAnalyzer | |
| ModelOptimizer |
use ../generators/NuSMV/NuSMVCoordinationUnit.ump;
|
| ModelRelationAssociationEndAnalyzer | |
| ModelRelationAssociationEndBoundAnalyzer | |
| ModelRelationOpAssociationAnalyzer | |
| ModelRelationOpAssociationOpAnalyzer | |
| ModelRelationOpAttributeAnalyzer | |
| ModelRelationOpAttributeClassificationAnalyzer | |
| ModelRelationOpInheritanceAnalyzer | |
| ModelRelationOpInheritanceSubclassAnalyzer | |
| ModelRelationOpInheritanceSuperclassAnalyzer | |
| ModuleBody | |
| ModuleElement | |
| Monitor | |
| MoreOpAnalyzer | |
| 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
|
| NegativeConstraintAnalyzer | |
| NewAction | |
| NewAssociationAction | |
| NewGeneralizationAction | |
| NewTransitionAction | |
| NextAssign | |
| NextExpression | |
| Node |
trait Node
{
boolean visited = false;
public void visit()
{
this.visited = true;
}
public void clear()
{
this.visited = false;
}
}
|
| NoExtendedFact | |
| NonReflexiveFact | |
| NoSelfRelationFact | |
| NotequalsOpAnalyzer | |
| NothingGenerator | |
| NumericBoundFact | |
| NumExprAnalyzer | |
| NumExprEqualsOpAnalyzer | |
| NumExprNotequalsOpAnalyzer | |
| NumExprNumberAnalyzer | |
| NuSMVCoordinator | |
| NuSMVGenerator | |
| NuSMVModule | |
| NuSMVOptimizerGenerator | |
| ObjectElement |
object element is any element with type value and name, such as attribute or Umple element.
|
| Objects | |
| OpenStatement | |
| OperatorConstants |
The common constants for logical operators
|
| OptionDescriptor |
Describes options that an option parser recognizes, in ways that might be useful to help screens.
|
| OptionException |
Thrown when a problem occurs during option parsing.
|
| OptionParser |
Parses command line arguments, using a syntax that attempts to take from the best of POSIX
getopt()
and GNU getopt_long(). |
| OptionSet |
Representation of a group of detected command line options, their arguments, and non-option arguments.
|
| OptionSpec<V> |
Describes options that an option parser recognizes.
|
| OptionSpecBuilder |
Allows callers to specify whether a given option accepts arguments (required or optional).
|
| OrOpAnalyzer | |
| Package |
A root class elemnt.
|
| PairDescriptor | |
| PapyrusGenerator | |
| PapyrusImportHandler |
Parse Papyrus
|
| ParagraphElement | |
| Parser |
Parses an Umple file (.ump) based on grammar rules.
|
| ParserAction |
This type of action is used only with useStatements at the moment but their general idea is that the parser can do some action
whenever it successfully contructs a certain token.
|
| ParserDataPackage |
ParserDataPackage is a structure which contains all the miscellaneous data during the parse.
|
| ParseResult |
Represents the results of parsing, such as if it was successful,
whether it had warnings, etc.
|
| ParsingCouple |
ParsingCouples are used by balanced rules to quickly find the corresponding brace.
|
| PhpClassGenerator | |
| PhpGenerator | |
| PhpInterfaceGenerator | |
| PlainRequirementsDocGenerator | |
| PlaygroundMain | |
| 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
|
| Port.Direction | |
| Port.Type | |
| PortBinding | |
| PortBindingInformation | |
| PortConstraint | |
| PortFunction | |
| Position |
Used to indicate the coordinates of a position when parsing.
|
| Postcondition |
The Preconditions are constraints on methods, throughing an exception if the constraint is not sastisfied after the method has computed.
|
| PostconditionAnalyzer | |
| Postfix | |
| Precondition |
The Preconditions are constraints on methods, restricting the method so that it does not process if the constraint is not satisfied.
|
| PreconditionAnalyzer | |
| Primitive | |
| Protocol | |
| PythonClassGenerator | |
| PythonGenerator | |
| Range | |
| Record |
class TraceRecord
{
Boolean recordOnly = false;
-> * UmpleVariable;
-> * Attribute;
1 -> * Record;
}
|
| Reflection |
Helper methods for reflection.
|
| ReflectionException |
This unchecked exception wraps reflection-oriented exceptions.
|
| RegexMatcher |
Ensures that values entirely match a regular expression.
|
| RepeatableRule |
name: [[rule]](option)
Repeatable rules are rules that are repeated sequencially one after the other in some form
option: ? means either the rule does not parse or it does once and only once, i.e.
|
| Requirement |
Represents a requirement, such as those found around classes, methods, attributes and associations.
|
| ReqVisitor | |
| RootRule |
The only difference between a root rule and a choice rule is that after parsing the parse position must be at the end of the file for this rule to pass
|
| Rows | |
| RTCppGenerator | |
| RubyClassGenerator | |
| RubyGenerator | |
| RubyInterfaceGenerator | |
| Rule |
Represents a grammar rule, which has a name and contains definitions that describe it.
|
| RuleBasedParser |
The rule based parser takes in umple grammar files and parses them into Rule objects(ChoiceRule, ChainRule, etc.).
|
| RuleBasedParserAction | |
| RuleBasedParserThread |
This class is for parsing multiple files at the same time.
|
| RuleInstance |
Data captured during parsing when a certain rule matches
|
| RulePart |
Part of a grammar rule
|
| RulePart.Type | |
| RulePartValue | |
| SampleFileWriter | |
| Scope |
Local variables
|
| ScriptElement | |
| ScxmlGenerator | |
| ScxmlImportHandler |
Parse SCXML by extend SAX handler callbacks
|
| Signature | |
| SimpleAssign | |
| SimpleMetricsGenerator | |
| SimulateGenerator | |
| SmallerOpAnalyzer | |
| SqlClassGenerator | |
| SqlGenerator | |
| SqlInterfaceGenerator | |
| 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.
|
| StatemachineExprAnalyzer | |
| StatemachineExprStateNameAnalyzer | |
| StateMachineGraph | |
| StateMachineMetrics | |
| StateMachineModifier | |
| StateMachineStatsVisitor |
Used to extract the required metrics information for the statemachines of a given class.
|
| StateMachineTemplateSignature | |
| StateMachineTraceItem | |
| Statement | |
| 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
|
| StateTableEntry |
Interface for each individual entry within a cell
|
| 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.
|
| StatsMain | |
| StringComplexExpressionAnalyzer | |
| StringComplexExpressionConcatAnalyzer | |
| StringExprAnalyzer | |
| StringExprQuoteAnalyzer | |
| StringFormatter | |
| Strings | |
| StringUtil | |
| StructureDiagramGenerator | |
| StructurePointsHandler | |
| StyleElement | |
| SuperCodeGenerator | |
| SuperGvGenerator | |
| SuperMemberInitializer | |
| SymmetricFact | |
| SynchronizationAction | |
| TableElement | |
| TargetConfiguration | |
| Template |
Set of html templates used in the Umple User manual for certain
kinds of page elements
|
| 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.
|
| TemplateException |
class TemplateException {
isA Exception;
Token token;
Integer errorCode;
String errMsg;
public TemplateException(Token aToken, int aErrorCode, String aErrMsg, Exception ex) {
super(aErrMsg, ex);
token = aToken;
errorCode = aErrorCode;
errMsg = aErrMsg;
}
public TemplateException(Token aToken, int aErrorCode, String aErrMsg) {
super(aErrMsg, null);
token = aToken;
errorCode = aErrorCode;
errMsg = aErrMsg;
}
}
|
| 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
|
| Terminal |
Terminals are the only rules that actually don't use sub rules, instead, they use regex to compute whether there is a successful parse.
|
| TestAction |
test action statements
|
| TestClassGenerator | |
| TestGenerator | |
| TestInit |
initialization statements in test that holds
identifier objectname (parameters);
|
| TestModelGenerator | |
| TestParameter | |
| TestSequence | |
| TextContents | |
| TextElement | |
| TextParser |
Parses textual input and used in conjunction with the umple parser and internal parser to tokenize the contents of a file such
as an Umple file.
|
| TextUmlGenerator | |
| TimerConstraint | |
| TimerConstraint.TimeConstraintType | |
| Token |
Fundamental to all parsing, used in conjunction with rules and their definitions.
|
| TokenAnalysisStub |
The stubs for the tokens to be analyzed
|
| 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
|
| TraceItem | |
| 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 | |
| TransConstraint | |
| 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 | |
| Trigger.TimeType | |
| TriState | |
| Uigu2ElementGenerator | |
| 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
|
| UmpleCompilerException | |
| UmpleConsoleConfig |
Config is the parsed command line information for UmpleConsole.
|
| UmpleConsoleMain |
Main program for the command line Umple compiler
Run java -jar umple.jar --help for details
Takes an umple file as an argument, which can in turn use (include) other
|
| UmpleCPPGenerationUtil | |
| UmpleCppPoliciesProcessor | |
| 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.
|
| UmpleInternalParser.Strictness | |
| UmpleLinkedFileHandler |
This is the LinkedFileHandler for the Umple language.
|
| UmpleModel |
Class UmpleModel is the central class describing the system being compiled.
|
| UmpleModelGenerationPolicy | |
| 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
|
| UmpleParser | |
| UmpleParserFactory | |
| UmpleRunMain |
Main program for a jar that can inject calls to Umple at runtime
|
| UmpleSelfGenerator | |
| UmpleStatemachineGenerationPolicy | |
| UmpleStructureGenerationPolicy | |
| 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 | |
| UniqueGenBody | |
| UniqueIdentifier | |
| UpdatePositioningAction | |
| USEGenerator | |
| UserCode |
It is used to track user code when processing objects information
|
| UseStatementParserAction |
This is the ParserAction to handle 'use' tokens in Umple.
|
| Utility | |
| 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.
|
| ValueConversionException |
Thrown by
ValueConverters when problems occur in converting string values to other Java types. |
| ValueConverter<V> |
Instances of this interface are used to convert arguments of options into specific Java types.
|
| VarDeclaration | |
| VariableElement | |
| VariableSpecifier | |
| VioletAssociation | |
| VioletClass | |
| VioletDiagram | |
| VioletGenerator | |
| Visibilities | |
| Word | |
| 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 |