User Manual    [Previous]   [Next]   

List of Umple Keywords

Here is the list of all keywords in the Umple modeling language. These cannot be used as identifiers in cases where that would cause confusion.

The following tags are used to group certain keywords

• [top] Keywords that can appear at the top level of an Umple model (see also the grammar for top level items).
• [class] Keywords that can appear at the top level inside a class (and also generally inside a trait) (see also the grammar for items that can appear in classes).
• [state machine] Keywords used to define state machines (see also the grammar for state machines).
• [attribute] Keywords used to define attributes.
• [method] Keywords used to define methods.
• [constraints] Keywords specially associated with runtime constraints.
• [model constraints] Keywords specially associated with model constraints (checked at compile time).
• [tracing] Keywords specially associated with the runtime tracing.
• [testing] Keywords specially associated with test generation.

• abstract: [class] [method] Specifies that a class or method is abstract. An abstract class can not have its own instances and instances must be created from subclasses. An abstract method has no body in this class and causes the class to be abstract. See Abstract Methods
• active: [class] Specifies that instances of the class will each automatically run their own thread. See Active Objects
• add: [tracing] Indicates that the tracing should occur when an association link is being added. See Tracing Associations
• after: [top] [class] [method] Requests that code should be injected after the existing code in one or more methods (either generated methods or methods written by the user) See Before and After Statements
• after: [state machine] Triggers a transition after a specified amount of time. See Timed Transitions
• after every: [state machine] Continuously triggers a transition at specified time intervals in a given state, while the object remains in that state. See Timed Transitions
• all: [method] In the context of a before, after or around statement, indicates that code should be injected in every method that matches the specified pattern (not just custom or generated code).
• and: [constraints] Logical AND operator used in constraints, which include state machine guards. See Simple Constraints.
• around: [top] [class] Specifies code will be inserted in place of matching methods. The original code is placed wherever the around_proceed keyword is found. See Around Statement
• around_proceed: In the context of an around statement, denotes where the original block of code should be placed. See Around Statement
• as: [state machine] Declares a state machine in a class that is a copy of a standalone state machine.See Standalone State Machines.
• assertAttribute: [testing] Asserts attribute's presence in generated code. See Basic Testcase
• assertEqual: [testing] Asserts that two objects are equal. See Basic Testcase
• assertFalse: [testing] Asserts that condition is false. See Basic Testcase
• assertMethod: [testing] Asserts methods's presence in generated code. See Basic Testcase
• assertNull: [testing] Asserts that object is null. See Basic Testcase
• assertTrue: [testing] Asserts that condition is true. See Basic Testcase
• association: [top] Defines an association between two classes, describing the links that can be defined at run time. This keyword is used when an association is created separately from the two classes. See Independently Defined Associations
• associationClass: [top] Defines a class in place of a many-to-many association. See association class definition
• attribute/attr: [model constraints] Used in model constraints to test whether an attribute matching a pattern exists. See model constraints
• autounique: [attribute] Automatically assigns a unique value to an attribute each time a class is instantiated. See unique attributes
• before: [top] [class] [method] Requests that code should be injected before existing code in one or more methods. See Before and After Statements
• cardinality: [constraints] [tracing] Operator that asserts the existence of a given number of instances of a class in an association. See Tracing Constraints
• class: [top] Defines a new class.This should be followed by a class name. See Class Definition
• const: [class] Defines a new constant. See Attribute Definition
• custom: [method] Indicates that code should be injected in every custom (user-written) method that matches the specified pattern, but not methods that are generated. See Code Injection in Custom Methods
• defaulted: [attribute] Provides a default value for an attribute. See Attribute Definition
• depend: [class] Denotes a dependency on another class, interface or namespace. See Depend Clause
• distributable: [class] [top] Allows for the execution of multiple objects accross different running Java Virtual Machines. See Basic Distributed Systems
• do: [state machine] Runs a process while in a state. See State Machine Actions and Do Activities
• emit: [class] Specifies the method to be generated for a particular template See Basic Templates
• entry: [state machine] Indicates an action to perform when entering a state. See State Machine Actions and Do Activities
• enum: [class] [top] Defines a user-defined data type with a set of constants. See Enumeration Definition
• exit: [state machine] Indicates an action to perform when exiting a state. See State Machine Actions and Do Activities
• false: [attribute] Boolean literal which a boolean attribute can be set to. See Umple Built in Data Types
• filter: [top] Defines a new filter to allow generation of code or diagrams from only a subset of classes and/or associations. See Filters
• final: [state machine] Precedes a state name and marks it as the final state of a state machine. See Final States
• Final: [state machine] Denotes the destination of a transition that terminates the state machine once completed. See Final States
• for: [tracing] Preceded by an attribute, denotes the number of times the attribute's value should be changed for tracing to occur. See Tracing Constraints
• forced: Preceded by a distributable statement, this sets all classes in the program to be distributable, that is, allowed to be instantiated on multiple machines. See Basic Distributed Systems
• generate: [top] Specifies the languages to be generated when compiling (Java is the default); can also be specified on the command line. See the list of keywords that can be specified in the grammar. A list is also available from the command line by specifying --help. There is also a section in the user manual that describes the capabilities of key generators.
• generated: [method] Indicates that code should be injected in every generated method that matches the specified pattern, but not custom methods. See Before and After Statements
• generic: [testing] Defines a new generic test, which is a template that generates test cases for elements matching a pattern specified by the user. See Generic Testing
• giving: [tracing] Operator that specifies part of the condition under which tracing occurs. See Tracing Constraints
• has: [model constraints] Operator that asserts the existence of an association between two classes. See model constraints
• hops: In the context of a filter statement, indicates additional classes that can be included, which are linked to the already included classes by associations or generalizations. See Filters
• ignore: Subsequent to a strictness statement, this denotes a warning that should not appear, in order to reduce clutter during compilation. See Strictness Directive
• immutable: [attribute] [class] Defines an attribute that only be set when initialized. At the class level, specifies that the whole class (all attributes and associations) will be immutable. See Immutable pattern
• include: Within a filter directive, it indicates the classes that are to be included. See Filters
• includeFilter: Within a filter directive, it indicates named filters to be included. See Filters
• inner: [class] Defines a new inner non-static class.
• interface: [top] Defines a new interface; specifies a set of methods that a class must implement. See interface Definition
• internal: [attribute] Denotes an internal attribute, for which no get or set statement will be generated, and which will not appear in the constructor. See Attribute definition
• isA: [class] Denotes a superclass, or implemented interface, or included trait. See isA clause
• key: [class] Marks an attribute or set of attributes as keys for equality and hashing. See Keys for Equality and Hashing
• lazy: [attribute] Causes the attribute to be initialized to a default value (0, false,empty string) according to its types, and ensures the attribute is not made an argument to the constructor. See attribute definition
• mixset: [top] Defines a new mixset, a named block of Umple that can be optionally included in the system, in order to create a variant or product line, or separately-defined feature. See basic mixsets
• model: [class] [model constraints] Defines specific conditions that must be satisfied by a model. See model constraints
• namespace: [top] Declares of group of classes that will be put in a package so as to avoid conflicts with classes having the same name in a different package. See namespace directives
• not: [constraints] Logical NOT operator used in constraints. See Simple Constraints.
• of: [model constraints] Denotes an object whose attribute is being evaluated. See model constraints
• off: Preceded by a distributable statement, this prevents all classes to be distributable. See Basic Distributed Systems
• or: [constraints] Logical OR operator used in constraints. See Simple Constraints.
• pooled: [state machine] Similar to a queued state machine that allows for the processing of events on separate threads but not always in the order they arrive, since if in a state that does not accept an incoming event, another acceptable transition that arrived later may be taken. See Pooled State Machines
• pre: [method] [constraints] Defines a pre-condition that must be satisfied to run a method. See preconditions
• prefix: [testing] Defines an element with a name that begins with the pattern specified. See Generic Testing
• private: [method] Sets the accessibility level of a class or its members to private. See Method Definition
• protected: [method] Sets the accessibility level of a class or its members to protected. See Method Definition
• public: [method] Sets the accessibility level of a class or its members to public. Can be omitted in Umple if the default is to be accepted (public methods, private attributes) See Method Definition
• queued: [state machine] Placed before the state machine declaration, this allows for the processing of events received by a state machine in a separate thread (to prevent deadlocks) and in the order they appear. See also pooled./ See Queued State Machines
• --redefine: Namespace option used to redefine a previously defined namespace. See Namespace Directives
• regex: [testing] Defines an element that matches the pattern specified. See Generic Testing
• remove: [tracing] Indicates that the tracing should occur when an association is deleted. See Tracing Associations
• RMI: Preceded by a distributable statement, this indicated the use of Remote Method Invocation (RMI) in a distributed system. See Basic Distributed Systems
• self: [class] This indicates a symmetric reflexive Association, an association from a class to itself for which there is no clear distinction between the association's ends. See Reflexive Association
• settable: [attribute] Denotes an attribute that can be set, which is the default, as opposed to immutable. See Attribute Definition
• singleton: [class] Marks a class as a singleton class, which can only have one instance. See singleton pattern
• sorted: [class] Specifies that elements of an association will be sorted according to an attribute. See Sorted Associations
• statemachine: [top] [state machine] Defines a state machine template at the top-level without including it in any class See Standalone State Machines
• static: [class] Defines an attribute or method to be static. A static attribute has only one value for the class. A static method can only access static attributes and other static methods.
• strictness: [top] Allows the control of messages that may be issued by the umple compiler, such as suppressing warnings. See strictness Directive
• sub: Within a hops statement of a filter, indicates the number of levels of subclasses to show. See Filters
• subclass: [model constraints] Used to assert the current class has a certain subclass defined elsewhere. See model constraints
• suffix: [testing] Defines an element with a name that ends with the pattern specified. See Generic Testing
• super: Within a hops statement of a filter, it indicates a numbered super class. See Filters
• superclass: [model constraints] Used to assert the current class has a certain superclass, defined elsewhere. See model constraints
• test: [testing] Defines a new test case. See Basic Testcase
• trace: [tracing] Indicates the UML entity to trace. See Tracing Basics
• tracer: [tracing] Indicates the tracer type to be used (Default is Console). See Tracers
• trait: [top] Defines a new trait, which is a group of class content items. See Traits
• true: [attribute] Boolean literal which a boolean attribute can be set to. See Umple Built in Data Types
• unique: [attribute] Ensures that an attribute has a particular value for each instance of a class. See unique attributes
• unspecified: [state machine] Ensures that no event in a state is ignored; transitions labelled unspecified are taken if an event arrives that matches no other transition in this state. See Unspecified Events
• until: [tracing] Boolean operator that makes up a condition under which tracing occurs. See Tracing Constraints
• use: [top] Allows your program to include a model or blocks of code from another file, or activates a mixset. See Use Statements
• where: [tracing] Boolean operator that makes up a condition under which tracing occurs. See Tracing Constraints
• WS: Preceded by a distributable statement, this indicates the use of web services in a distributed system. See Basic Distributed Systems