All Classes and Interfaces
Class
Description
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.
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
A quickly-executed block of code that is run upon entry or exit from a state
NEW CLASS****************************************
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.
log analysis errors
Abstraction for task parser to be analyzed.
Analyze call
This is the base class for all Analyzers used in the GrammarAnalyzer.
This is a handler/delegate class that handles construction of Analyzer classes
at runtime.
Specification of an option that accepts an argument.
BEGIN_COPYRIGHT_BLOCK
Copyright (c) 2001-2010, JavaPLT group at Rice University (drjava@rice.edu)
All rights reserved.
Represents an association, typically between two Umple classes (1-1, 1-*, *-1, etc).
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.
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
Data class to hold a 2D matrix of links between 2 classes (for 1 association)
Call getLinksFromAssociation() in order to populate the "links" attribute
An association variable represents one of the variables used to represent
an association.
Represents an attribute.
An element of a trace directive that indicates to trace one or more attributes
Balanced rules ensure that braces are balanced, that is, that the corresponding brace is matched.
A help formatter that allows configuration of overall row width and column separator width.
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.
name : [[rule]] ( | [[rule]] )*
The basic parsing rule.
Data class to hold the number of class instances
Class to hold the number of class instances for a given umple model
Provides methods/algorithms to calculate the number of class instances
A pattern object is used to persist Patentable information for a class elemnt such as
abstract, delegate, immutable, etc.
Used to extract the required metrics information for the states of a given class.
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.
Scriplet segment in a template
Allows independent code generation tools
Different generators will do different things regarding where the files are put, etc.
Default implementation for generators with suboptions
A block of code that can be injected into one or more methods, constructor, etc.
Represents a comment, such as those found around classes, methods, attributes and associations.
Comment segment for a template contents
The common constants for code generation
The common return type constants
Container containing multiple concurrent states.
Walk through definition tree while analyzing template tokens
Used as a helper class to analyze tokens in a given component
Container containing multiple transitions of the same name
A compund feature has multiple of features (like xor , or and other that have multiplicity.)
Used to associated condition patern for an umple elemnt.
Represents a constant.
ConstraintAttributes encapsulate the association for the constraint, this will be a leaf on the constraint tree.
ConstraintAttributes encapsulate the attribute for the constraint, this will be a leaf on the constraint tree
ConstraintLiterals encapulate raw data literals, such as strings, numbers and booleans, that do not have an model variable associated.
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.
This super class contains all subclasses that have elements with names
Number literals are the special case of literals, where the value they contained is garanteed to be a number.
ConstraintOperators encapsulate the branching of the constraint tree, where the branches occur at the operators, for example
[ainvalid input: '<'3invalid input: '&'invalid input: '&b'!="loved"]
the basic structure will look like
ConstraintOperator(invalid input: '&'invalid input: '&')
/ \
ConstraintOperator(invalid input: '<') ConstraintOperator(!=)
/ \ / \
ConstraintAttribute(a) ConstraintNumberLiteral(3) ConstraintAttribute(b) ConstraintLiteral("loved")
With the extra complication that ConstraintTrees parent everything that are not ConstraintLiterals
ConstraintPort encapsulate the statemachine data in a port watch expression
ConstraintStates encapsulate the state data in a statemachine expression such as [sm is in state st], this is a leaf in the constraint tree/
ConstraintStateMachines encapsulate the statemachine data in a statemachine expression such as [sm is in state st], this is a leaf in the constraint tree.
ConstraintTrees are a redundant class that are necessary because of lone constraints, i.e.
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.
ConstraintVariables encapsulate that data of one element in a ConstraintTree, making up the nodes of that tree.
Data for the user manual taken from one of the files in
build/reference
Specialist parser for the Umple user manual
Parses files in build/reference/*
A Coordinate is used in the layout of classes
It represents the shape of a class box in a diagram
end of class ClassMetrics
This class is used like a structure to help keep values about lines
END OF CLASS StateMachineMetrics
CountSM class used to calculate State Machine Metrics.
An open-close pair, such as open curly brackets and close curly brackets
Used to identify block start and end while parsing
The common constants for C++ code generation
The common return type constants
Helper data class capturing a single association link between two
concrete instances as recorded by the CRUD UI.
Converts values to
Dates using a DateFormat object.A depend relationship indicates a package on which this class depends
The tool to create the html text of the Umple user manual
Parse ECore by extend SAX handler callbacks
Represents an error message, typically used with parsing.
Represents an error type, which contains an error code, the severity of the error, etc.
Lists all the errors in the system
NEW CLASS****************************************
A row in the list-style output
This is used to remove an event or a transition.
Represents a cell in a row in the Event Sequence table.
Represents a cell in a row in the first row of a Event Sequence table.
This is the list-style view for the event sequence.
The grid-type view of the event sequence, with the possible states as rows
and the sequence of events as columns.
Represents the header row of a Event Sequence table.
Represents a row in the Event Sequence table.
Contains the templates for both the event sequence UI types
Allows mapping from events to the various transitions.
Expression segment in a template
This is used to extend a state with a state machine.
A FeatureLeaf contains a full mixset or a full file.
A FeatureLink connects a source feature to target feature(s) in the feature diagram.
Copyright: All contributers to the Umple Project.
A Feature model consists of some FeatureNodels, which can be leaf nodes or fragmentFeature nodes.
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.
A FragmentFeatureLeaf consists of one or more mixset fragments.
List handlers (vector vs set); cpp-specific
Helper methods for many relations
Constructor roles
Setter roles
Delete roles
Add roles
Copyright (c) 2017 Ahmed M.Orabi, Mahmoud M.Orabi.
class GenDepend{
String includeNamespace(){
GenClass genClass= getGenClass();
if(genClass!= null){
return genClass.includeNamespace();
}
return getNamespace();
}
namespace= {includeNamespace()};
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Composite-structure-specific
This class is used to specify parameters for traits.
This class is used to assign parameters in classes and traits.
Represents a class that is generated from an Umple class, such as a Java or Cpp class.
TODO: Code smell: This duplicates the structure of the class from UmpleClass
This is a problem for model-to-model transformations
Should be abolished
Represents the generation target, such as what the generated output language will be.
Statemachine-specific
STL-specific
Test-specifid
Umple-specific
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
CPP-specfific
Copyright (c) 2017 Ahmed M.Orabi, Mahmoud M.Orabi.
/////////////////////////////////////////////
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.
A section of the Umple user manual
Defined in the build/references/order.group
A boolean condition that is checked when an event method is called
If the result is true the transition may be taken
NEW CLASS****************************************
Represents objects charged with taking a set of option descriptions and producing some help text from them.
Used to persist hirarchy information for given elemnts (owner, and children)
Walk through template tree while analyzing template tokens
Walk through template tree while analyzing template tokens
TODO: These classes - should be refactored out
Include segment in a template
Converts values to
InetAddress using getByName.Data class to hold the computed instance diagram information so it can be reused
without generating GraphViz output.
The common STL return type constants
Generator HTML utils are designed to proivde a standlone HTML elements generation using Umple.
User can define their own walker that receives an UmpleModelVisitor to visit a given element contents
A key in a class is a set of attributes associations used to uniquely identify an object
A simple string key/string value pair.
This is a handler/delegate class that handles linked files supplied at
compile time.
LLOC metrics vistor.
McCabe = Edges - Nodes + 2 * ExitNodes
McCabe = Edges - Nodes + ExitNodes
McCabe = Number of logical points + 1
Designed to be implemnted ny metric classes.
pririoriy constraint
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.
The contents of a method, such as the code within it.
Represents a parameter in a method and its various forms.
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
Each mixset statement creates a MixSetFragment
This class keeps references to mixsets which are iside methods
A MixsetOrFile is an umple entity that is subject to require logic
use ../generators/NuSMV/NuSMVCoordinationUnit.ump;
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 is a special type of FeatureLink in which there are min and max multiplicity.
added for issue 1315 warning 31
trait Node
{
boolean visited = false;
public void visit()
{
this.visited = true;
}
public void clear()
{
this.visited = false;
}
}
object element is any element with type value and name, such as attribute or Umple element.
The common constants for logical operators
Describes options that an option parser recognizes, in ways that might be useful to help screens.
Thrown when a problem occurs during option parsing.
Parses command line arguments, using a syntax that attempts to take from the best of POSIX
getopt()
and GNU getopt_long().Representation of a group of detected command line options, their arguments, and non-option arguments.
Describes options that an option parser recognizes.
Allows callers to specify whether a given option accepts arguments (required or optional).
A root class elemnt.
Parse Papyrus
Parses an Umple file (.ump) based on grammar rules.
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 is a structure which contains all the miscellaneous data during the parse.
Represents the results of parsing, such as if it was successful,
whether it had warnings, etc.
ParsingCouples are used by balanced rules to quickly find the corresponding brace.
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
component
Used to indicate the coordinates of a position when parsing.
The Preconditions are constraints on methods, throughing an exception if the constraint is not sastisfied after the method has computed.
The Preconditions are constraints on methods, restricting the method so that it does not process if the constraint is not satisfied.
class TraceRecord
{
Boolean recordOnly = false;
-> * UmpleVariable;
-> * Attribute;
1 -> * Record;
}
Helper methods for reflection.
This unchecked exception wraps reflection-oriented exceptions.
Ensures that values entirely match a regular expression.
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.
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
Represents a requirement, such as those found around
classes, methods, attributes, associations, stateMachines, states, etc.
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
Represents a grammar rule, which has a name and contains definitions that describe it.
The rule based parser takes in umple grammar files and parses them into Rule objects(ChoiceRule, ChainRule, etc.).
This class is for parsing multiple files at the same time.
Data captured during parsing when a certain rule matches
Part of a grammar rule
Local variables
Parse SCXML by extend SAX handler callbacks
One of the values in which a state machine can be at any given point in time
NEW CLASS****************************************
Cell entries for state-event tables
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.
Used to extract the required metrics information for the statemachines of a given class.
This is used to remove and rename a state.
Cell entries for state-state tables
Cell in a state table containing the resulting state or the event that results in transition
Interface for each individual entry within a cell
Row in a state-state table and state-event table
Also iterated through as columns in a state-state-table
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.
Set of html templates used in the Umple User manual for certain
kinds of page elements
Parse existing attributes in a template
Walk through definition tree while analyzing template tokens
A template element represents template contents to be built.
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;
}
}
A template filed reprsents a field with a value for emitting purposes
Method rpesentations in a template
Used as a helper class to analyze tokens in a given template
Terminals are the only rules that actually don't use sub rules, instead, they use regex to compute whether there is a successful parse.
test action statements
initialization statements in test that holds
identifier objectname (parameters);
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.
Fundamental to all parsing, used in conjunction with rules and their definitions.
The stubs for the tokens to be analyzed
This class used to represent the binary tree of require-statement argument
Ex: require [A and B or C] will be formed as:
...
Future work - initial implementation is done
A group of trace directives that can be switched on or off by other
trace directives
Discarded metamodel
TraceConstraint objects ensure that the attribute being traced will be treated as a parameter and not a member variable
----- 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
Util class that has common method called from different trace items
----- Tracer Directive MetaModel
A statement found in Umple that directs tracing technology
to be used in generted code
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.
This is the AnalyzerGeneratorHandler for the Umple language
This handler constructs Analyzers by name by using reflection
in the `cruise.umple.analysis` namespace
The assertion within the method or class.
An UmpleClass can contain attributes, associations, state machines and methods.
Represents an Umple classifier: a Class or Interface
Config is the parsed command line information for UmpleConsole.
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
An UmpleElement is one of the top-level items found in an Umple model
Currently it has one subclass, UmpleClassifier
Represents an enumeration
This class already exists in the util subdirectory
It is used for the main file, and there is code
to add linkedfiles.
Defines import prototype for package, class, interface
and associations
integration of all importElements as a model
ImportType is a "enumeration" of information for what type of
file was imported.
Represents a interface.
This is our internal parser implementation for the Umple language.
This is the LinkedFileHandler for the Umple language.
Class UmpleModel is the central class describing the system being compiled.
A common util for the implemented Measurment objects (@see MeasurmentObject).
It is designed to visit different types of umple elemnts so it can process and understand
the defined walkers (@see IWalker).
A generic walker that is designed to parse different types of umple elements.
UmpleObject is used to initialize classes
Main program for a jar that can inject calls to Umple at runtime
Test Case at the Class level .
An UmpleTrait can contain attributes, associations, state machines and methods.
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
It is used to track user code when processing objects information
This is the ParserAction to handle 'use' tokens in Umple.
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.
Thrown by
ValueConverters when problems occur in converting string values to other Java types.Instances of this interface are used to convert arguments of options into specific Java types.
used for random name generation for the instance diagram generator
XORFeatureConnectingOpType is a special type of FeatureLink in which lower invalid input: '&' upper bounds of the set are limited to 1 (i.e.