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.
|
| ReqImplementation |
Represents an implementation of a requirement
Stored to allow for analysis of matching requirement
and reporting on what features implement what requirement
all instances of this class are tracked in the instance of the model
with the association allReqImplementations
Note that there can be multiple instances of this class for each identifier
because, for example, multiple methods may be needed to implement a given requirement
|
| Requirement |
Represents a requirement, such as those found around
classes, methods, attributes, associations, stateMachines, states, etc.
|
| 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 |