InteractionOperatorKind (UML2 Javadoc)

java.lang.Object
- java.lang.Enum<InteractionOperatorKind>
- - org.eclipse.uml2.uml.InteractionOperatorKind

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<InteractionOperatorKind>, org.eclipse.emf.common.util.Enumerator
```
public enum InteractionOperatorKind
extends java.lang.Enum<InteractionOperatorKind>
implements org.eclipse.emf.common.util.Enumerator
```
A representation of the literals of the enumeration 'Interaction Operator Kind', and utility methods for working with them. InteractionOperatorKind is an enumeration designating the different kinds of operators of CombinedFragments. The InteractionOperand defines the type of operator of a CombinedFragment.
From package UML::Interactions.

See Also:

UMLPackage.getInteractionOperatorKind()

Enum Constant Summary

Enum Constants
Enum Constant and Description
`ALT_LITERAL` The 'Alt' literal object
`ASSERT_LITERAL` The 'Assert' literal object
`BREAK_LITERAL` The 'Break' literal object
`CONSIDER_LITERAL` The 'Consider' literal object
`CRITICAL_LITERAL` The 'Critical' literal object
`IGNORE_LITERAL` The 'Ignore' literal object
`LOOP_LITERAL` The 'Loop' literal object
`NEG_LITERAL` The 'Neg' literal object
`OPT_LITERAL` The 'Opt' literal object
`PAR_LITERAL` The 'Par' literal object
`SEQ_LITERAL` The 'Seq' literal object
`STRICT_LITERAL` The 'Strict' literal object

Field Summary

Fields
Modifier and Type	Field and Description
`static int`	`ALT` The 'Alt' literal value
`static int`	`ASSERT` The 'Assert' literal value
`static int`	`BREAK` The 'Break' literal value
`static int`	`CONSIDER` The 'Consider' literal value
`static int`	`CRITICAL` The 'Critical' literal value
`static int`	`IGNORE` The 'Ignore' literal value
`static int`	`LOOP` The 'Loop' literal value
`static int`	`NEG` The 'Neg' literal value
`static int`	`OPT` The 'Opt' literal value
`static int`	`PAR` The 'Par' literal value
`static int`	`SEQ` The 'Seq' literal value
`static int`	`STRICT` The 'Strict' literal value
`static java.util.List<InteractionOperatorKind>`	`VALUES` A public read-only list of all the 'Interaction Operator Kind' enumerators

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static InteractionOperatorKind`	`get(int value)` Returns the 'Interaction Operator Kind' literal with the specified integer value
`static InteractionOperatorKind`	`get(java.lang.String literal)` Returns the 'Interaction Operator Kind' literal with the specified literal value
`static InteractionOperatorKind`	`getByName(java.lang.String name)` Returns the 'Interaction Operator Kind' literal with the specified name
`java.lang.String`	`getLiteral()`
`java.lang.String`	`getName()`
`int`	`getValue()`
`java.lang.String`	`toString()` Returns the literal value of the enumerator, which is its string representation
`static InteractionOperatorKind`	`valueOf(java.lang.String name)` Returns the enum constant of this type with the specified name.
`static InteractionOperatorKind[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Enum Constant Detail
  - SEQ_LITERAL
```
public static final InteractionOperatorKind SEQ_LITERAL
```
    The 'Seq' literal object.
    
    See Also:
    
    SEQ
  - ALT_LITERAL
```
public static final InteractionOperatorKind ALT_LITERAL
```
    The 'Alt' literal object.
    
    See Also:
    
    ALT
  - OPT_LITERAL
```
public static final InteractionOperatorKind OPT_LITERAL
```
    The 'Opt' literal object.
    
    See Also:
    
    OPT
  - BREAK_LITERAL
```
public static final InteractionOperatorKind BREAK_LITERAL
```
    The 'Break' literal object.
    
    See Also:
    
    BREAK
  - PAR_LITERAL
```
public static final InteractionOperatorKind PAR_LITERAL
```
    The 'Par' literal object.
    
    See Also:
    
    PAR
  - STRICT_LITERAL
```
public static final InteractionOperatorKind STRICT_LITERAL
```
    The 'Strict' literal object.
    
    See Also:
    
    STRICT
  - LOOP_LITERAL
```
public static final InteractionOperatorKind LOOP_LITERAL
```
    The 'Loop' literal object.
    
    See Also:
    
    LOOP
  - CRITICAL_LITERAL
```
public static final InteractionOperatorKind CRITICAL_LITERAL
```
    The 'Critical' literal object.
    
    See Also:
    
    CRITICAL
  - NEG_LITERAL
```
public static final InteractionOperatorKind NEG_LITERAL
```
    The 'Neg' literal object.
    
    See Also:
    
    NEG
  - ASSERT_LITERAL
```
public static final InteractionOperatorKind ASSERT_LITERAL
```
    The 'Assert' literal object.
    
    See Also:
    
    ASSERT
  - IGNORE_LITERAL
```
public static final InteractionOperatorKind IGNORE_LITERAL
```
    The 'Ignore' literal object.
    
    See Also:
    
    IGNORE
  - CONSIDER_LITERAL
```
public static final InteractionOperatorKind CONSIDER_LITERAL
```
    The 'Consider' literal object.
    
    See Also:
    
    CONSIDER
- Field Detail
  - SEQ
```
public static final int SEQ
```
    The 'Seq' literal value. The InteractionOperatorKind seq designates that the CombinedFragment represents a weak sequencing between the behaviors of the operands.
    
    See Also:
    
    SEQ_LITERAL, Constant Field Values
  - ALT
```
public static final int ALT
```
    The 'Alt' literal value. The InteractionOperatorKind alt designates that the CombinedFragment represents a choice of behavior. At most one of the operands will be chosen. The chosen operand must have an explicit or implicit guard expression that evaluates to true at this point in the interaction. An implicit true guard is implied if the operand has no guard.
    
    See Also:
    
    ALT_LITERAL, Constant Field Values
  - OPT
```
public static final int OPT
```
    The 'Opt' literal value. The InteractionOperatorKind opt designates that the CombinedFragment represents a choice of behavior where either the (sole) operand happens or nothing happens. An option is semantically equivalent to an alternative CombinedFragment where there is one operand with non-empty content and the second operand is empty.
    
    See Also:
    
    OPT_LITERAL, Constant Field Values
  - BREAK
```
public static final int BREAK
```
    The 'Break' literal value. The InteractionOperatorKind break designates that the CombinedFragment represents a breaking scenario in the sense that the operand is a scenario that is performed instead of the remainder of the enclosing InteractionFragment. A break operator with a guard is chosen when the guard is true and the rest of the enclosing Interaction Fragment is ignored. When the guard of the break operand is false, the break operand is ignored and the rest of the enclosing InteractionFragment is chosen. The choice between a break operand without a guard and the rest of the enclosing InteractionFragment is done non-deterministically.
    
    See Also:
    
    BREAK_LITERAL, Constant Field Values
  - PAR
```
public static final int PAR
```
    The 'Par' literal value. The InteractionOperatorKind par designates that the CombinedFragment represents a parallel merge between the behaviors of the operands. The OccurrenceSpecifications of the different operands can be interleaved in any way as long as the ordering imposed by each operand as such is preserved.
    
    See Also:
    
    PAR_LITERAL, Constant Field Values
  - STRICT
```
public static final int STRICT
```
    The 'Strict' literal value. The InteractionOperatorKind strict designates that the CombinedFragment represents a strict sequencing between the behaviors of the operands. The semantics of strict sequencing defines a strict ordering of the operands on the first level within the CombinedFragment with interactionOperator strict. Therefore OccurrenceSpecifications within contained CombinedFragment will not directly be compared with other OccurrenceSpecifications of the enclosing CombinedFragment.
    
    See Also:
    
    STRICT_LITERAL, Constant Field Values
  - LOOP
```
public static final int LOOP
```
    The 'Loop' literal value. The InteractionOperatorKind loop designates that the CombinedFragment represents a loop. The loop operand will be repeated a number of times.
    
    See Also:
    
    LOOP_LITERAL, Constant Field Values
  - CRITICAL
```
public static final int CRITICAL
```
    The 'Critical' literal value. The InteractionOperatorKind critical designates that the CombinedFragment represents a critical region. A critical region means that the traces of the region cannot be interleaved by other OccurrenceSpecifications (on those Lifelines covered by the region). This means that the region is treated atomically by the enclosing fragment when determining the set of valid traces. Even though enclosing CombinedFragments may imply that some OccurrenceSpecifications may interleave into the region, such as with par-operator, this is prevented by defining a region.
    
    See Also:
    
    CRITICAL_LITERAL, Constant Field Values
  - NEG
```
public static final int NEG
```
    The 'Neg' literal value. The InteractionOperatorKind neg designates that the CombinedFragment represents traces that are defined to be invalid.
    
    See Also:
    
    NEG_LITERAL, Constant Field Values
  - ASSERT
```
public static final int ASSERT
```
    The 'Assert' literal value. The InteractionOperatorKind assert designates that the CombinedFragment represents an assertion. The sequences of the operand of the assertion are the only valid continuations. All other continuations result in an invalid trace.
    
    See Also:
    
    ASSERT_LITERAL, Constant Field Values
  - IGNORE
```
public static final int IGNORE
```
    The 'Ignore' literal value. The InteractionOperatorKind ignore designates that there are some message types that are not shown within this combined fragment. These message types can be considered insignificant and are implicitly ignored if they appear in a corresponding execution. Alternatively, one can understand ignore to mean that the message types that are ignored can appear anywhere in the traces.
    
    See Also:
    
    IGNORE_LITERAL, Constant Field Values
  - CONSIDER
```
public static final int CONSIDER
```
    The 'Consider' literal value. The InteractionOperatorKind consider designates which messages should be considered within this combined fragment. This is equivalent to defining every other message to be ignored.
    
    See Also:
    
    CONSIDER_LITERAL, Constant Field Values
  - VALUES
```
public static final java.util.List<InteractionOperatorKind> VALUES
```
    A public read-only list of all the 'Interaction Operator Kind' enumerators.
- Method Detail
  - values
```
public static InteractionOperatorKind[] values()
```
    Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
```
for (InteractionOperatorKind c : InteractionOperatorKind.values())
    System.out.println(c);
```
    Returns:
    
    an array containing the constants of this enum type, in the order they are declared
  - valueOf
```
public static InteractionOperatorKind valueOf(java.lang.String name)
```
    Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
    
    Parameters:
    
    name - the name of the enum constant to be returned.
    
    Returns:
    
    the enum constant with the specified name
    
    Throws:
    
    java.lang.IllegalArgumentException - if this enum type has no constant with the specified name
    
    java.lang.NullPointerException - if the argument is null
  - get
```
public static InteractionOperatorKind get(java.lang.String literal)
```
    Returns the 'Interaction Operator Kind' literal with the specified literal value.
    
    Parameters:
    
    literal - the literal.
    
    Returns:
    
    the matching enumerator or null.
  - getByName
```
public static InteractionOperatorKind getByName(java.lang.String name)
```
    Returns the 'Interaction Operator Kind' literal with the specified name.
    
    Parameters:
    
    name - the name.
    
    Returns:
    
    the matching enumerator or null.
  - get
```
public static InteractionOperatorKind get(int value)
```
    Returns the 'Interaction Operator Kind' literal with the specified integer value.
    
    Parameters:
    
    value - the integer value.
    
    Returns:
    
    the matching enumerator or null.
  - getValue
```
public int getValue()
```
    Specified by:
    
    getValue in interface org.eclipse.emf.common.util.Enumerator
  - getName
```
public java.lang.String getName()
```
    Specified by:
    
    getName in interface org.eclipse.emf.common.util.Enumerator
  - getLiteral
```
public java.lang.String getLiteral()
```
    Specified by:
    
    getLiteral in interface org.eclipse.emf.common.util.Enumerator
  - toString
```
public java.lang.String toString()
```
    Returns the literal value of the enumerator, which is its string representation.
    
    Overrides:
    
    toString in class java.lang.Enum<InteractionOperatorKind>

Enum InteractionOperatorKind

Enum Constant Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

SEQ_LITERAL

ALT_LITERAL

OPT_LITERAL

BREAK_LITERAL

PAR_LITERAL

STRICT_LITERAL

LOOP_LITERAL

CRITICAL_LITERAL

NEG_LITERAL

ASSERT_LITERAL

IGNORE_LITERAL

CONSIDER_LITERAL

Field Detail

SEQ

ALT

OPT

BREAK

PAR

STRICT

LOOP

CRITICAL

NEG

ASSERT

IGNORE

CONSIDER

VALUES

Method Detail

values

valueOf

get

getByName

get

getValue

getName

getLiteral

toString