1------------------------------------------------------------------------------
2--                                                                          --
3--                            Matreshka Project                             --
4--                                                                          --
5--                          Ada Modeling Framework                          --
6--                                                                          --
7--                        Runtime Library Component                         --
8--                                                                          --
9------------------------------------------------------------------------------
10--                                                                          --
11-- Copyright © 2011-2012, Vadim Godunko <vgodunko@gmail.com>                --
12-- All rights reserved.                                                     --
13--                                                                          --
14-- Redistribution and use in source and binary forms, with or without       --
15-- modification, are permitted provided that the following conditions       --
16-- are met:                                                                 --
17--                                                                          --
18--  * Redistributions of source code must retain the above copyright        --
19--    notice, this list of conditions and the following disclaimer.         --
20--                                                                          --
21--  * Redistributions in binary form must reproduce the above copyright     --
22--    notice, this list of conditions and the following disclaimer in the   --
23--    documentation and/or other materials provided with the distribution.  --
24--                                                                          --
25--  * Neither the name of the Vadim Godunko, IE nor the names of its        --
26--    contributors may be used to endorse or promote products derived from  --
27--    this software without specific prior written permission.              --
28--                                                                          --
29-- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS      --
30-- "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT        --
31-- LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    --
32-- A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT     --
33-- HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,   --
34-- SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED --
35-- TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR   --
36-- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF   --
37-- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING     --
38-- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS       --
39-- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.             --
40--                                                                          --
41------------------------------------------------------------------------------
42--  $Revision: 2714 $ $Date: 2012-03-24 10:29:08 +0400 (Sat, 24 Mar 2012) $
43------------------------------------------------------------------------------
44--  This file is generated, don't edit it.
45------------------------------------------------------------------------------
46--  A state models a situation during which some (usually implicit) invariant
47--  condition holds.
48--
49--  The states of protocol state machines are exposed to the users of their
50--  context classifiers. A protocol state represents an exposed stable
51--  situation of its context classifier: when an instance of the classifier is
52--  not processing any operation, users of this instance can always know its
53--  state configuration.
54------------------------------------------------------------------------------
55limited with AMF.UML.Behaviors;
56limited with AMF.UML.Classifiers;
57limited with AMF.UML.Connection_Point_References.Collections;
58limited with AMF.UML.Constraints;
59with AMF.UML.Namespaces;
60limited with AMF.UML.Pseudostates.Collections;
61with AMF.UML.Redefinable_Elements;
62limited with AMF.UML.Regions.Collections;
63limited with AMF.UML.State_Machines;
64limited with AMF.UML.Triggers.Collections;
65with AMF.UML.Vertexs;
66
67package AMF.UML.States is
68
69   pragma Preelaborate;
70
71   type UML_State is limited interface
72     and AMF.UML.Redefinable_Elements.UML_Redefinable_Element
73     and AMF.UML.Namespaces.UML_Namespace
74     and AMF.UML.Vertexs.UML_Vertex;
75
76   type UML_State_Access is
77     access all UML_State'Class;
78   for UML_State_Access'Storage_Size use 0;
79
80   not overriding function Get_Connection
81    (Self : not null access constant UML_State)
82       return AMF.UML.Connection_Point_References.Collections.Set_Of_UML_Connection_Point_Reference is abstract;
83   --  Getter of State::connection.
84   --
85   --  The entry and exit connection points used in conjunction with this
86   --  (submachine) state, i.e. as targets and sources, respectively, in the
87   --  region with the submachine state. A connection point reference
88   --  references the corresponding definition of a connection point
89   --  pseudostate in the statemachine referenced by the submachinestate.
90
91   not overriding function Get_Connection_Point
92    (Self : not null access constant UML_State)
93       return AMF.UML.Pseudostates.Collections.Set_Of_UML_Pseudostate is abstract;
94   --  Getter of State::connectionPoint.
95   --
96   --  The entry and exit pseudostates of a composite state. These can only be
97   --  entry or exit Pseudostates, and they must have different names. They
98   --  can only be defined for composite states.
99
100   not overriding function Get_Deferrable_Trigger
101    (Self : not null access constant UML_State)
102       return AMF.UML.Triggers.Collections.Set_Of_UML_Trigger is abstract;
103   --  Getter of State::deferrableTrigger.
104   --
105   --  A list of triggers that are candidates to be retained by the state
106   --  machine if they trigger no transitions out of the state (not consumed).
107   --  A deferred trigger is retained until the state machine reaches a state
108   --  configuration where it is no longer deferred.
109
110   not overriding function Get_Do_Activity
111    (Self : not null access constant UML_State)
112       return AMF.UML.Behaviors.UML_Behavior_Access is abstract;
113   --  Getter of State::doActivity.
114   --
115   --  An optional behavior that is executed while being in the state. The
116   --  execution starts when this state is entered, and stops either by
117   --  itself, or when the state is exited, whichever comes first.
118
119   not overriding procedure Set_Do_Activity
120    (Self : not null access UML_State;
121     To   : AMF.UML.Behaviors.UML_Behavior_Access) is abstract;
122   --  Setter of State::doActivity.
123   --
124   --  An optional behavior that is executed while being in the state. The
125   --  execution starts when this state is entered, and stops either by
126   --  itself, or when the state is exited, whichever comes first.
127
128   not overriding function Get_Entry
129    (Self : not null access constant UML_State)
130       return AMF.UML.Behaviors.UML_Behavior_Access is abstract;
131   --  Getter of State::entry.
132   --
133   --  An optional behavior that is executed whenever this state is entered
134   --  regardless of the transition taken to reach the state. If defined,
135   --  entry actions are always executed to completion prior to any internal
136   --  behavior or transitions performed within the state.
137
138   not overriding procedure Set_Entry
139    (Self : not null access UML_State;
140     To   : AMF.UML.Behaviors.UML_Behavior_Access) is abstract;
141   --  Setter of State::entry.
142   --
143   --  An optional behavior that is executed whenever this state is entered
144   --  regardless of the transition taken to reach the state. If defined,
145   --  entry actions are always executed to completion prior to any internal
146   --  behavior or transitions performed within the state.
147
148   not overriding function Get_Exit
149    (Self : not null access constant UML_State)
150       return AMF.UML.Behaviors.UML_Behavior_Access is abstract;
151   --  Getter of State::exit.
152   --
153   --  An optional behavior that is executed whenever this state is exited
154   --  regardless of which transition was taken out of the state. If defined,
155   --  exit actions are always executed to completion only after all internal
156   --  activities and transition actions have completed execution.
157
158   not overriding procedure Set_Exit
159    (Self : not null access UML_State;
160     To   : AMF.UML.Behaviors.UML_Behavior_Access) is abstract;
161   --  Setter of State::exit.
162   --
163   --  An optional behavior that is executed whenever this state is exited
164   --  regardless of which transition was taken out of the state. If defined,
165   --  exit actions are always executed to completion only after all internal
166   --  activities and transition actions have completed execution.
167
168   not overriding function Get_Is_Composite
169    (Self : not null access constant UML_State)
170       return Boolean is abstract;
171   --  Getter of State::isComposite.
172   --
173   --  A state with isComposite=true is said to be a composite state. A
174   --  composite state is a state that contains at least one region.
175
176   not overriding function Get_Is_Orthogonal
177    (Self : not null access constant UML_State)
178       return Boolean is abstract;
179   --  Getter of State::isOrthogonal.
180   --
181   --  A state with isOrthogonal=true is said to be an orthogonal composite
182   --  state. An orthogonal composite state contains two or more regions.
183
184   not overriding function Get_Is_Simple
185    (Self : not null access constant UML_State)
186       return Boolean is abstract;
187   --  Getter of State::isSimple.
188   --
189   --  A state with isSimple=true is said to be a simple state. A simple state
190   --  does not have any regions and it does not refer to any submachine state
191   --  machine.
192
193   not overriding function Get_Is_Submachine_State
194    (Self : not null access constant UML_State)
195       return Boolean is abstract;
196   --  Getter of State::isSubmachineState.
197   --
198   --  A state with isSubmachineState=true is said to be a submachine state.
199   --  Such a state refers to a state machine (submachine).
200
201   not overriding function Get_Redefined_State
202    (Self : not null access constant UML_State)
203       return AMF.UML.States.UML_State_Access is abstract;
204   --  Getter of State::redefinedState.
205   --
206   --  The state of which this state is a redefinition.
207
208   not overriding procedure Set_Redefined_State
209    (Self : not null access UML_State;
210     To   : AMF.UML.States.UML_State_Access) is abstract;
211   --  Setter of State::redefinedState.
212   --
213   --  The state of which this state is a redefinition.
214
215   not overriding function Get_Redefinition_Context
216    (Self : not null access constant UML_State)
217       return AMF.UML.Classifiers.UML_Classifier_Access is abstract;
218   --  Getter of State::redefinitionContext.
219   --
220   --  References the classifier in which context this element may be
221   --  redefined.
222
223   not overriding function Get_Region
224    (Self : not null access constant UML_State)
225       return AMF.UML.Regions.Collections.Set_Of_UML_Region is abstract;
226   --  Getter of State::region.
227   --
228   --  The regions owned directly by the state.
229
230   not overriding function Get_State_Invariant
231    (Self : not null access constant UML_State)
232       return AMF.UML.Constraints.UML_Constraint_Access is abstract;
233   --  Getter of State::stateInvariant.
234   --
235   --  Specifies conditions that are always true when this state is the
236   --  current state. In protocol state machines, state invariants are
237   --  additional conditions to the preconditions of the outgoing transitions,
238   --  and to the postcondition of the incoming transitions.
239
240   not overriding procedure Set_State_Invariant
241    (Self : not null access UML_State;
242     To   : AMF.UML.Constraints.UML_Constraint_Access) is abstract;
243   --  Setter of State::stateInvariant.
244   --
245   --  Specifies conditions that are always true when this state is the
246   --  current state. In protocol state machines, state invariants are
247   --  additional conditions to the preconditions of the outgoing transitions,
248   --  and to the postcondition of the incoming transitions.
249
250   not overriding function Get_Submachine
251    (Self : not null access constant UML_State)
252       return AMF.UML.State_Machines.UML_State_Machine_Access is abstract;
253   --  Getter of State::submachine.
254   --
255   --  The state machine that is to be inserted in place of the (submachine)
256   --  state.
257
258   not overriding procedure Set_Submachine
259    (Self : not null access UML_State;
260     To   : AMF.UML.State_Machines.UML_State_Machine_Access) is abstract;
261   --  Setter of State::submachine.
262   --
263   --  The state machine that is to be inserted in place of the (submachine)
264   --  state.
265
266   overriding function Containing_State_Machine
267    (Self : not null access constant UML_State)
268       return AMF.UML.State_Machines.UML_State_Machine_Access is abstract;
269   --  Operation State::containingStateMachine.
270   --
271   --  The query containingStateMachine() returns the state machine that
272   --  contains the state either directly or transitively.
273
274   not overriding function Is_Composite
275    (Self : not null access constant UML_State)
276       return Boolean is abstract;
277   --  Operation State::isComposite.
278   --
279   --  A composite state is a state with at least one region.
280
281   overriding function Is_Consistent_With
282    (Self : not null access constant UML_State;
283     Redefinee : AMF.UML.Redefinable_Elements.UML_Redefinable_Element_Access)
284       return Boolean is abstract;
285   --  Operation State::isConsistentWith.
286   --
287   --  The query isConsistentWith() specifies that a redefining state is
288   --  consistent with a redefined state provided that the redefining state is
289   --  an extension of the redefined state: A simple state can be redefined
290   --  (extended) to become a composite state (by adding a region) and a
291   --  composite state can be redefined (extended) by adding regions and by
292   --  adding vertices, states, and transitions to inherited regions. All
293   --  states may add or replace entry, exit, and 'doActivity' actions.
294
295   not overriding function Is_Orthogonal
296    (Self : not null access constant UML_State)
297       return Boolean is abstract;
298   --  Operation State::isOrthogonal.
299   --
300   --  An orthogonal state is a composite state with at least 2 regions
301
302   not overriding function Is_Redefinition_Context_Valid
303    (Self : not null access constant UML_State;
304     Redefined : AMF.UML.States.UML_State_Access)
305       return Boolean is abstract;
306   --  Operation State::isRedefinitionContextValid.
307   --
308   --  The query isRedefinitionContextValid() specifies whether the
309   --  redefinition contexts of a state are properly related to the
310   --  redefinition contexts of the specified state to allow this element to
311   --  redefine the other. The containing region of a redefining state must
312   --  redefine the containing region of the redefined state.
313
314   not overriding function Is_Simple
315    (Self : not null access constant UML_State)
316       return Boolean is abstract;
317   --  Operation State::isSimple.
318   --
319   --  A simple state is a state without any regions.
320
321   not overriding function Is_Submachine_State
322    (Self : not null access constant UML_State)
323       return Boolean is abstract;
324   --  Operation State::isSubmachineState.
325   --
326   --  Only submachine states can have a reference statemachine.
327
328   not overriding function Redefinition_Context
329    (Self : not null access constant UML_State)
330       return AMF.UML.Classifiers.UML_Classifier_Access is abstract;
331   --  Operation State::redefinitionContext.
332   --
333   --  The redefinition context of a state is the nearest containing
334   --  statemachine.
335
336end AMF.UML.States;
337