finiteStateMachines.py

#------------------------------------------------------------------------------
#     This code was generated by a tool.
#
#     Changes to this file can cause unexpected behaviour
#     and get lost when the code gets generated again.
#------------------------------------------------------------------------------
from pyNMF import *
from pyNMF.collections.generic import *
from pyNMF.collections.object_model import *
from pyNMF.serialization import *


"""The default implementation of the FiniteStateMachine class"""
class FiniteStateMachine(ModelElement):
    """type(__id) == str, type(IdChanging) == System.EventHandler, type(IdChanged) == System.EventHandler, type(__states) == ObservableCompositionOrderedSet, type(__transitions) == ObservableCompositionOrderedSet"""
    
    """The backing field for the Id property"""
    @staticmethod
    def _typeOfID():
        return str
    
    """The backing field for the States property"""
    @staticmethod
    def _typeOfSTATES():
        return State
    
    """The backing field for the Transitions property"""
    @staticmethod
    def _typeOfTRANSITIONS():
        return Transition
    
    def __init__(self):
        super(FiniteStateMachine, self).__init__()
        self._ConstructorFieldInitFunction()
        self.__states = ObservableCompositionOrderedSet(self)
        self.__states.CollectionChanging += self._StatesCollectionChanging
        self.__states.CollectionChanged += self._StatesCollectionChanged
        self.__transitions = ObservableCompositionOrderedSet(self)
        self.__transitions.CollectionChanging += self._TransitionsCollectionChanging
        self.__transitions.CollectionChanged += self._TransitionsCollectionChanged
    
    
    """The id property"""
    def get_Id(self):
        return self.__id
    
    def set_Id(self, value):
        if self.__id != value:
            old = self.__id
            e = ValueChangedEventArgs(old, value)
            self.OnIdChanging(e)
            self.OnPropertyChanging('Id', e)
            self.__id = value
            self.OnIdChanged(e)
            self.OnPropertyChanged('Id', e)
    
    Id = property(fget=get_Id,fset=set_Id,doc="""The id property""")
    
    
    """The states property"""
    def get_States(self):
        return self.__states
    
    States = property(fget=get_States,doc="""The states property""")
    
    
    """The transitions property"""
    def get_Transitions(self):
        return self.__transitions
    
    Transitions = property(fget=get_Transitions,doc="""The transitions property""")
    
    
    """Gets the child model elements of this model element"""
    def get_Children(self):
        return super(FiniteStateMachine, self).Children.Concat(FiniteStateMachineChildrenCollection(self))
    
    Children = property(fget=get_Children,doc="""Gets the child model elements of this model element""")
    
    
    """Gets the referenced model elements of this model element"""
    def get_ReferencedElements(self):
        return super(FiniteStateMachine, self).ReferencedElements.Concat(FiniteStateMachineReferencedElementsCollection(self))
    
    ReferencedElements = property(fget=get_ReferencedElements,doc="""Gets the referenced model elements of this model element""")
    
    
    """Gets a value indicating whether the current model element can be identified by an attribute value"""
    def get_IsIdentified(self):
        return True
    
    IsIdentified = property(fget=get_IsIdentified,doc="""Gets a value indicating whether the current model element can be identified by an attribute value""")
    
    
    """Gets fired before the Id property changes its value"""
    
    """Gets fired when the Id property changed its value"""
    
    def OnIdChanging(self, eventArgs):
        """
         Raises the IdChanging event
        
         :param eventArgs: The event data
        """
        handler = self.IdChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnIdChanged(self, eventArgs):
        """
         Raises the IdChanged event
        
         :param eventArgs: The event data
        """
        handler = self.IdChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def _StatesCollectionChanging(self, sender, e):
        """
         Forwards CollectionChanging notifications for the States property to the parent model element
        
         :param sender: The collection that raised the change
         :param e: The original event data
        """
        self.OnCollectionChanging('States', e)
    
    
    def _StatesCollectionChanged(self, sender, e):
        """
         Forwards CollectionChanged notifications for the States property to the parent model element
        
         :param sender: The collection that raised the change
         :param e: The original event data
        """
        self.OnCollectionChanged('States', e)
    
    
    def _TransitionsCollectionChanging(self, sender, e):
        """
         Forwards CollectionChanging notifications for the Transitions property to the parent model element
        
         :param sender: The collection that raised the change
         :param e: The original event data
        """
        self.OnCollectionChanging('Transitions', e)
    
    
    def _TransitionsCollectionChanged(self, sender, e):
        """
         Forwards CollectionChanged notifications for the Transitions property to the parent model element
        
         :param sender: The collection that raised the change
         :param e: The original event data
        """
        self.OnCollectionChanged('Transitions', e)
    
    
    def GetRelativePathForNonIdentifiedChild(self, element):
        """
         Gets the relative URI fragment for the given child model element
        
         :returns: A fragment of the relative URI
         :param element: The element that should be looked for
        """
        statesIndex = ModelHelper.IndexOfReference(self.States, element)
        if statesIndex != -1:
            return ModelHelper.CreatePath('states', statesIndex)
        transitionsIndex = ModelHelper.IndexOfReference(self.Transitions, element)
        if transitionsIndex != -1:
            return ModelHelper.CreatePath('transitions', transitionsIndex)
        return super(FiniteStateMachine, self).GetRelativePathForNonIdentifiedChild(element)
    
    
    def GetModelElementForReference(self, reference, index):
        """
         Resolves the given URI to a child model element
        
         :returns: The model element or null if it could not be found
         :param reference: The requested reference name
         :param index: The index of this reference
        """
        if reference == 'STATES':
            if index < self.States.Count:
                return self.States[index]
            else:
                return None
        if reference == 'TRANSITIONS':
            if index < self.Transitions.Count:
                return self.Transitions[index]
            else:
                return None
        return super(FiniteStateMachine, self).GetModelElementForReference(reference, index)
    
    
    def GetAttributeValue(self, attribute, index):
        """
         Resolves the given attribute name
        
         :returns: The attribute value or null if it could not be found
         :param attribute: The requested attribute name
         :param index: The index of this attribute
        """
        if attribute == 'ID':
            return self.Id
        return super(FiniteStateMachine, self).GetAttributeValue(attribute, index)
    
    
    def GetCollectionForFeature(self, feature):
        """
         Gets the Model element collection for the given feature
        
         :returns: A non-generic list of elements
         :param feature: The requested feature
        """
        if feature == 'STATES':
            return self.__states
        if feature == 'TRANSITIONS':
            return self.__transitions
        return super(FiniteStateMachine, self).GetCollectionForFeature(feature)
    
    
    def SetFeature(self, feature, value):
        """
         Sets a value to the given feature
        
         :param feature: The requested feature
         :param value: The value that should be set to that feature
        """
        if feature == 'ID':
            self.Id = value
            return 
        super(FiniteStateMachine, self).SetFeature(feature, value)
    
    
    def GetCompositionName(self, container):
        """
         Gets the property name for the given container
        
         :returns: The name of the respective container reference
         :param container: The container object
        """
        if container == self.__states:
            return 'states'
        if container == self.__transitions:
            return 'transitions'
        return super(FiniteStateMachine, self).GetCompositionName(container)
    
    
    def ToIdentifierString(self):
        """
         Gets the identifier string for this model element
        
         :returns: The identifier string
        """
        if self.Id is None:
            return None
        return str(self.Id)
    
    
    def CreateUriWithFragment(self, fragment, absolute, baseElement):
        return self.CreateUriFromGlobalIdentifier(fragment, absolute)
    
    
    def PropagateNewModel(self, newModel, oldModel, subtreeRoot):
        id = self.ToIdentifierString()
        if oldModel != None:
            oldModel.UnregisterId(id)
        if newModel != None:
            newModel.RegisterId(id, self)
        super(FiniteStateMachine, self).PropagateNewModel(newModel, oldModel, subtreeRoot)
    
    
    class FiniteStateMachineChildrenCollection(ReferenceCollection,CollectionExpression,Collection):
        """type(__parent) == FiniteStateMachine"""
        
        @staticmethod
        def _typeOfPARENT():
            return FiniteStateMachine
        
        def __init__(self, parent):
            super(FiniteStateMachineChildrenCollection, self).__init__()
            self._ConstructorFieldInitFunction()
            self.__parent = parent
        
        
        """Gets the amount of elements contained in this collection"""
        def get_Count(self):
            count = 0
            count = count + self.__parent.States.Count
            count = count + self.__parent.Transitions.Count
            return count
        
        Count = property(fget=get_Count,doc="""Gets the amount of elements contained in this collection""")
        
        
        def AttachCore(self):
            self.__parent.States.AsNotifiable().CollectionChanged += self.PropagateCollectionChanges
            self.__parent.Transitions.AsNotifiable().CollectionChanged += self.PropagateCollectionChanges
        
        
        def DetachCore(self):
            self.__parent.States.AsNotifiable().CollectionChanged -= self.PropagateCollectionChanges
            self.__parent.Transitions.AsNotifiable().CollectionChanged -= self.PropagateCollectionChanges
        
        
        def Add(self, item):
            """
             Adds the given element to the collection
            
             :param item: The item to add
            """
            statesCasted = item.As()
            if statesCasted != None:
                self.__parent.States.Add(statesCasted)
            transitionsCasted = item.As()
            if transitionsCasted != None:
                self.__parent.Transitions.Add(transitionsCasted)
        
        
        def Clear(self):
            """Clears the collection and resets all references that implement it."""
            self.__parent.States.Clear()
            self.__parent.Transitions.Clear()
        
        
        def Contains(self, item):
            """
             Gets a value indicating whether the given element is contained in the collection
            
             :returns: True, if it is contained, otherwise False
             :param item: The item that should be looked out for
            """
            if self.__parent.States.Contains(item):
                return True
            if self.__parent.Transitions.Contains(item):
                return True
            return False
        
        
        def CopyTo(self, array, arrayIndex):
            """
             Copies the contents of the collection to the given array starting from the given array index
            
             :param array: The array in which the elements should be copied
             :param arrayIndex: The starting index
            """
            statesEnumerator = self.__parent.States.GetEnumerator()
            try:
            # Snippet Statement

            # End Snippet Statement
                while statesEnumerator.MoveNext():
                    array[arrayIndex] = statesEnumerator.Current
                    arrayIndex = arrayIndex + 1
            # Snippet Statement

            # End Snippet Statement
            finally:
                statesEnumerator.Dispose()
            transitionsEnumerator = self.__parent.Transitions.GetEnumerator()
            try:
            # Snippet Statement

            # End Snippet Statement
                while transitionsEnumerator.MoveNext():
                    array[arrayIndex] = transitionsEnumerator.Current
                    arrayIndex = arrayIndex + 1
            # Snippet Statement

            # End Snippet Statement
            finally:
                transitionsEnumerator.Dispose()
        
        
        def Remove(self, item):
            """
             Removes the given item from the collection
            
             :returns: True, if the item was removed, otherwise False
             :param item: The item that should be removed
            """
            stateItem = item.As()
            if stateItem != None and self.__parent.States.Remove(stateItem):
                return True
            transitionItem = item.As()
            if transitionItem != None and self.__parent.Transitions.Remove(transitionItem):
                return True
            return False
        
        
        def GetEnumerator(self):
            """
             Gets an enumerator that enumerates the collection
            
             :returns: A generic enumerator
            """
            return Enumerable.Empty().Concat(self.__parent.States).Concat(self.__parent.Transitions).GetEnumerator()
        
        def _ConstructorFieldInitFunction(self):
            self.__parent = None
    
    
    class FiniteStateMachineReferencedElementsCollection(ReferenceCollection,CollectionExpression,Collection):
        """type(__parent) == FiniteStateMachine"""
        
        @staticmethod
        def _typeOfPARENT():
            return FiniteStateMachine
        
        def __init__(self, parent):
            super(FiniteStateMachineReferencedElementsCollection, self).__init__()
            self._ConstructorFieldInitFunction()
            self.__parent = parent
        
        
        """Gets the amount of elements contained in this collection"""
        def get_Count(self):
            count = 0
            count = count + self.__parent.States.Count
            count = count + self.__parent.Transitions.Count
            return count
        
        Count = property(fget=get_Count,doc="""Gets the amount of elements contained in this collection""")
        
        
        def AttachCore(self):
            self.__parent.States.AsNotifiable().CollectionChanged += self.PropagateCollectionChanges
            self.__parent.Transitions.AsNotifiable().CollectionChanged += self.PropagateCollectionChanges
        
        
        def DetachCore(self):
            self.__parent.States.AsNotifiable().CollectionChanged -= self.PropagateCollectionChanges
            self.__parent.Transitions.AsNotifiable().CollectionChanged -= self.PropagateCollectionChanges
        
        
        def Add(self, item):
            """
             Adds the given element to the collection
            
             :param item: The item to add
            """
            statesCasted = item.As()
            if statesCasted != None:
                self.__parent.States.Add(statesCasted)
            transitionsCasted = item.As()
            if transitionsCasted != None:
                self.__parent.Transitions.Add(transitionsCasted)
        
        
        def Clear(self):
            """Clears the collection and resets all references that implement it."""
            self.__parent.States.Clear()
            self.__parent.Transitions.Clear()
        
        
        def Contains(self, item):
            """
             Gets a value indicating whether the given element is contained in the collection
            
             :returns: True, if it is contained, otherwise False
             :param item: The item that should be looked out for
            """
            if self.__parent.States.Contains(item):
                return True
            if self.__parent.Transitions.Contains(item):
                return True
            return False
        
        
        def CopyTo(self, array, arrayIndex):
            """
             Copies the contents of the collection to the given array starting from the given array index
            
             :param array: The array in which the elements should be copied
             :param arrayIndex: The starting index
            """
            statesEnumerator = self.__parent.States.GetEnumerator()
            try:
            # Snippet Statement

            # End Snippet Statement
                while statesEnumerator.MoveNext():
                    array[arrayIndex] = statesEnumerator.Current
                    arrayIndex = arrayIndex + 1
            # Snippet Statement

            # End Snippet Statement
            finally:
                statesEnumerator.Dispose()
            transitionsEnumerator = self.__parent.Transitions.GetEnumerator()
            try:
            # Snippet Statement

            # End Snippet Statement
                while transitionsEnumerator.MoveNext():
                    array[arrayIndex] = transitionsEnumerator.Current
                    arrayIndex = arrayIndex + 1
            # Snippet Statement

            # End Snippet Statement
            finally:
                transitionsEnumerator.Dispose()
        
        
        def Remove(self, item):
            """
             Removes the given item from the collection
            
             :returns: True, if the item was removed, otherwise False
             :param item: The item that should be removed
            """
            stateItem = item.As()
            if stateItem != None and self.__parent.States.Remove(stateItem):
                return True
            transitionItem = item.As()
            if transitionItem != None and self.__parent.Transitions.Remove(transitionItem):
                return True
            return False
        
        
        def GetEnumerator(self):
            """
             Gets an enumerator that enumerates the collection
            
             :returns: A generic enumerator
            """
            return Enumerable.Empty().Concat(self.__parent.States).Concat(self.__parent.Transitions).GetEnumerator()
        
        def _ConstructorFieldInitFunction(self):
            self.__parent = None
    
    def _ConstructorFieldInitFunction(self):
        self.__id = None
        self.IdChanging = EventHandler()
        self.IdChanged = EventHandler()
        self.__states = None
        self.__transitions = None


class State(ModelElement):
    """type(__isEndState) == bool, type(IsEndStateChanging) == System.EventHandler, type(IsEndStateChanged) == System.EventHandler, type(__isStartState) == bool, type(IsStartStateChanging) == System.EventHandler, type(IsStartStateChanged) == System.EventHandler, type(__name) == str, type(NameChanging) == System.EventHandler, type(NameChanged) == System.EventHandler, type(__transitions) == StateTransitionsCollection"""
    
    """The backing field for the IsEndState property"""
    @staticmethod
    def _typeOfISENDSTATE():
        return bool
    
    """The backing field for the IsStartState property"""
    @staticmethod
    def _typeOfISSTARTSTATE():
        return bool
    
    """The backing field for the Name property"""
    @staticmethod
    def _typeOfNAME():
        return str
    
    """The backing field for the Transitions property"""
    @staticmethod
    def _typeOfTRANSITIONS():
        return Transition
    
    def __init__(self):
        super(State, self).__init__()
        self._ConstructorFieldInitFunction()
        self.__transitions = StateTransitionsCollection(self)
        self.__transitions.CollectionChanging += self._TransitionsCollectionChanging
        self.__transitions.CollectionChanged += self._TransitionsCollectionChanged
    
    
    """The isEndState property"""
    def get_IsEndState(self):
        return self.__isEndState
    
    def set_IsEndState(self, value):
        if self.__isEndState != value:
            old = self.__isEndState
            e = ValueChangedEventArgs(old, value)
            self.OnIsEndStateChanging(e)
            self.OnPropertyChanging('IsEndState', e)
            self.__isEndState = value
            self.OnIsEndStateChanged(e)
            self.OnPropertyChanged('IsEndState', e)
    
    IsEndState = property(fget=get_IsEndState,fset=set_IsEndState,doc="""The isEndState property""")
    
    
    """The isStartState property"""
    def get_IsStartState(self):
        return self.__isStartState
    
    def set_IsStartState(self, value):
        if self.__isStartState != value:
            old = self.__isStartState
            e = ValueChangedEventArgs(old, value)
            self.OnIsStartStateChanging(e)
            self.OnPropertyChanging('IsStartState', e)
            self.__isStartState = value
            self.OnIsStartStateChanged(e)
            self.OnPropertyChanged('IsStartState', e)
    
    IsStartState = property(fget=get_IsStartState,fset=set_IsStartState,doc="""The isStartState property""")
    
    
    """The name property"""
    def get_Name(self):
        return self.__name
    
    def set_Name(self, value):
        if self.__name != value:
            old = self.__name
            e = ValueChangedEventArgs(old, value)
            self.OnNameChanging(e)
            self.OnPropertyChanging('Name', e)
            self.__name = value
            self.OnNameChanged(e)
            self.OnPropertyChanged('Name', e)
    
    Name = property(fget=get_Name,fset=set_Name,doc="""The name property""")
    
    
    """The transitions property"""
    def get_Transitions(self):
        return self.__transitions
    
    Transitions = property(fget=get_Transitions,doc="""The transitions property""")
    
    
    """Gets the referenced model elements of this model element"""
    def get_ReferencedElements(self):
        return super(State, self).ReferencedElements.Concat(StateReferencedElementsCollection(self))
    
    ReferencedElements = property(fget=get_ReferencedElements,doc="""Gets the referenced model elements of this model element""")
    
    
    """Gets a value indicating whether the current model element can be identified by an attribute value"""
    def get_IsIdentified(self):
        return True
    
    IsIdentified = property(fget=get_IsIdentified,doc="""Gets a value indicating whether the current model element can be identified by an attribute value""")
    
    
    """Gets fired before the IsEndState property changes its value"""
    
    """Gets fired when the IsEndState property changed its value"""
    
    """Gets fired before the IsStartState property changes its value"""
    
    """Gets fired when the IsStartState property changed its value"""
    
    """Gets fired before the Name property changes its value"""
    
    """Gets fired when the Name property changed its value"""
    
    def OnIsEndStateChanging(self, eventArgs):
        """
         Raises the IsEndStateChanging event
        
         :param eventArgs: The event data
        """
        handler = self.IsEndStateChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnIsEndStateChanged(self, eventArgs):
        """
         Raises the IsEndStateChanged event
        
         :param eventArgs: The event data
        """
        handler = self.IsEndStateChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnIsStartStateChanging(self, eventArgs):
        """
         Raises the IsStartStateChanging event
        
         :param eventArgs: The event data
        """
        handler = self.IsStartStateChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnIsStartStateChanged(self, eventArgs):
        """
         Raises the IsStartStateChanged event
        
         :param eventArgs: The event data
        """
        handler = self.IsStartStateChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnNameChanging(self, eventArgs):
        """
         Raises the NameChanging event
        
         :param eventArgs: The event data
        """
        handler = self.NameChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnNameChanged(self, eventArgs):
        """
         Raises the NameChanged event
        
         :param eventArgs: The event data
        """
        handler = self.NameChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def _TransitionsCollectionChanging(self, sender, e):
        """
         Forwards CollectionChanging notifications for the Transitions property to the parent model element
        
         :param sender: The collection that raised the change
         :param e: The original event data
        """
        self.OnCollectionChanging('Transitions', e)
    
    
    def _TransitionsCollectionChanged(self, sender, e):
        """
         Forwards CollectionChanged notifications for the Transitions property to the parent model element
        
         :param sender: The collection that raised the change
         :param e: The original event data
        """
        self.OnCollectionChanged('Transitions', e)
    
    
    def GetAttributeValue(self, attribute, index):
        """
         Resolves the given attribute name
        
         :returns: The attribute value or null if it could not be found
         :param attribute: The requested attribute name
         :param index: The index of this attribute
        """
        if attribute == 'ISENDSTATE':
            return self.IsEndState
        if attribute == 'ISSTARTSTATE':
            return self.IsStartState
        if attribute == 'NAME':
            return self.Name
        return super(State, self).GetAttributeValue(attribute, index)
    
    
    def GetCollectionForFeature(self, feature):
        """
         Gets the Model element collection for the given feature
        
         :returns: A non-generic list of elements
         :param feature: The requested feature
        """
        if feature == 'TRANSITIONS':
            return self.__transitions
        return super(State, self).GetCollectionForFeature(feature)
    
    
    def SetFeature(self, feature, value):
        """
         Sets a value to the given feature
        
         :param feature: The requested feature
         :param value: The value that should be set to that feature
        """
        if feature == 'ISENDSTATE':
            self.IsEndState = value
            return 
        if feature == 'ISSTARTSTATE':
            self.IsStartState = value
            return 
        if feature == 'NAME':
            self.Name = value
            return 
        super(State, self).SetFeature(feature, value)
    
    
    def ToIdentifierString(self):
        """
         Gets the identifier string for this model element
        
         :returns: The identifier string
        """
        if self.Name is None:
            return None
        return str(self.Name)
    
    
    def CreateUriWithFragment(self, fragment, absolute, baseElement):
        return self.CreateUriFromGlobalIdentifier(fragment, absolute)
    
    
    def PropagateNewModel(self, newModel, oldModel, subtreeRoot):
        id = self.ToIdentifierString()
        if oldModel != None:
            oldModel.UnregisterId(id)
        if newModel != None:
            newModel.RegisterId(id, self)
        super(State, self).PropagateNewModel(newModel, oldModel, subtreeRoot)
    
    
    class StateReferencedElementsCollection(ReferenceCollection,CollectionExpression,Collection):
        """type(__parent) == State"""
        
        @staticmethod
        def _typeOfPARENT():
            return State
        
        def __init__(self, parent):
            super(StateReferencedElementsCollection, self).__init__()
            self._ConstructorFieldInitFunction()
            self.__parent = parent
        
        
        """Gets the amount of elements contained in this collection"""
        def get_Count(self):
            count = 0
            count = count + self.__parent.Transitions.Count
            return count
        
        Count = property(fget=get_Count,doc="""Gets the amount of elements contained in this collection""")
        
        
        def AttachCore(self):
            self.__parent.Transitions.AsNotifiable().CollectionChanged += self.PropagateCollectionChanges
        
        
        def DetachCore(self):
            self.__parent.Transitions.AsNotifiable().CollectionChanged -= self.PropagateCollectionChanges
        
        
        def Add(self, item):
            """
             Adds the given element to the collection
            
             :param item: The item to add
            """
            transitionsCasted = item.As()
            if transitionsCasted != None:
                self.__parent.Transitions.Add(transitionsCasted)
        
        
        def Clear(self):
            """Clears the collection and resets all references that implement it."""
            self.__parent.Transitions.Clear()
        
        
        def Contains(self, item):
            """
             Gets a value indicating whether the given element is contained in the collection
            
             :returns: True, if it is contained, otherwise False
             :param item: The item that should be looked out for
            """
            if self.__parent.Transitions.Contains(item):
                return True
            return False
        
        
        def CopyTo(self, array, arrayIndex):
            """
             Copies the contents of the collection to the given array starting from the given array index
            
             :param array: The array in which the elements should be copied
             :param arrayIndex: The starting index
            """
            transitionsEnumerator = self.__parent.Transitions.GetEnumerator()
            try:
            # Snippet Statement

            # End Snippet Statement
                while transitionsEnumerator.MoveNext():
                    array[arrayIndex] = transitionsEnumerator.Current
                    arrayIndex = arrayIndex + 1
            # Snippet Statement

            # End Snippet Statement
            finally:
                transitionsEnumerator.Dispose()
        
        
        def Remove(self, item):
            """
             Removes the given item from the collection
            
             :returns: True, if the item was removed, otherwise False
             :param item: The item that should be removed
            """
            transitionItem = item.As()
            if transitionItem != None and self.__parent.Transitions.Remove(transitionItem):
                return True
            return False
        
        
        def GetEnumerator(self):
            """
             Gets an enumerator that enumerates the collection
            
             :returns: A generic enumerator
            """
            return Enumerable.Empty().Concat(self.__parent.Transitions).GetEnumerator()
        
        def _ConstructorFieldInitFunction(self):
            self.__parent = None
    
    def _ConstructorFieldInitFunction(self):
        self.__isEndState = False
        self.IsEndStateChanging = EventHandler()
        self.IsEndStateChanged = EventHandler()
        self.__isStartState = False
        self.IsStartStateChanging = EventHandler()
        self.IsStartStateChanged = EventHandler()
        self.__name = None
        self.NameChanging = EventHandler()
        self.NameChanged = EventHandler()
        self.__transitions = None


class Transition(ModelElement):
    """type(__input) == str, type(InputChanging) == System.EventHandler, type(InputChanged) == System.EventHandler, type(__startState) == State, type(StartStateChanging) == System.EventHandler, type(StartStateChanged) == System.EventHandler, type(__endState) == State, type(EndStateChanging) == System.EventHandler, type(EndStateChanged) == System.EventHandler"""
    
    """The backing field for the Input property"""
    @staticmethod
    def _typeOfINPUT():
        return str
    
    """The backing field for the StartState property"""
    @staticmethod
    def _typeOfSTARTSTATE():
        return State
    
    """The backing field for the EndState property"""
    @staticmethod
    def _typeOfENDSTATE():
        return State
    
    def __init__(self):
        super(Transition, self).__init__()
        self._ConstructorFieldInitFunction()
        super(Transition, self).__init__()
    
    """The input property"""
    def get_Input(self):
        return self.__input
    
    def set_Input(self, value):
        if self.__input != value:
            old = self.__input
            e = ValueChangedEventArgs(old, value)
            self.OnInputChanging(e)
            self.OnPropertyChanging('Input', e)
            self.__input = value
            self.OnInputChanged(e)
            self.OnPropertyChanged('Input', e)
    
    Input = property(fget=get_Input,fset=set_Input,doc="""The input property""")
    
    
    """The startState property"""
    def get_StartState(self):
        return self.__startState
    
    def set_StartState(self, value):
        if self.__startState != value:
            old = self.__startState
            e = ValueChangedEventArgs(old, value)
            self.OnStartStateChanging(e)
            self.OnPropertyChanging('StartState', e)
            self.__startState = value
            if old != None:
                old.Transitions.Remove(self)
                old.Deleted -= self._OnResetStartState
            if value != None:
                value.Transitions.Add(self)
                value.Deleted += self._OnResetStartState
            self.OnStartStateChanged(e)
            self.OnPropertyChanged('StartState', e)
    
    StartState = property(fget=get_StartState,fset=set_StartState,doc="""The startState property""")
    
    
    """The endState property"""
    def get_EndState(self):
        return self.__endState
    
    def set_EndState(self, value):
        if self.__endState != value:
            old = self.__endState
            e = ValueChangedEventArgs(old, value)
            self.OnEndStateChanging(e)
            self.OnPropertyChanging('EndState', e)
            self.__endState = value
            if old != None:
                old.Deleted -= self._OnResetEndState
            if value != None:
                value.Deleted += self._OnResetEndState
            self.OnEndStateChanged(e)
            self.OnPropertyChanged('EndState', e)
    
    EndState = property(fget=get_EndState,fset=set_EndState,doc="""The endState property""")
    
    
    """Gets the referenced model elements of this model element"""
    def get_ReferencedElements(self):
        return super(Transition, self).ReferencedElements.Concat(TransitionReferencedElementsCollection(self))
    
    ReferencedElements = property(fget=get_ReferencedElements,doc="""Gets the referenced model elements of this model element""")
    
    
    """Gets fired before the Input property changes its value"""
    
    """Gets fired when the Input property changed its value"""
    
    """Gets fired before the StartState property changes its value"""
    
    """Gets fired when the StartState property changed its value"""
    
    """Gets fired before the EndState property changes its value"""
    
    """Gets fired when the EndState property changed its value"""
    
    def OnInputChanging(self, eventArgs):
        """
         Raises the InputChanging event
        
         :param eventArgs: The event data
        """
        handler = self.InputChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnInputChanged(self, eventArgs):
        """
         Raises the InputChanged event
        
         :param eventArgs: The event data
        """
        handler = self.InputChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnStartStateChanging(self, eventArgs):
        """
         Raises the StartStateChanging event
        
         :param eventArgs: The event data
        """
        handler = self.StartStateChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnStartStateChanged(self, eventArgs):
        """
         Raises the StartStateChanged event
        
         :param eventArgs: The event data
        """
        handler = self.StartStateChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def _OnResetStartState(self, sender, eventArgs):
        """
         Handles the event that the StartState property must reset
        
         :param sender: The object that sent this reset request
         :param eventArgs: The event data for the reset event
        """
        self.StartState = None
    
    
    def OnEndStateChanging(self, eventArgs):
        """
         Raises the EndStateChanging event
        
         :param eventArgs: The event data
        """
        handler = self.EndStateChanging
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def OnEndStateChanged(self, eventArgs):
        """
         Raises the EndStateChanged event
        
         :param eventArgs: The event data
        """
        handler = self.EndStateChanged
        if handler != None:
            handler.Invoke(self, eventArgs)
    
    
    def _OnResetEndState(self, sender, eventArgs):
        """
         Handles the event that the EndState property must reset
        
         :param sender: The object that sent this reset request
         :param eventArgs: The event data for the reset event
        """
        self.EndState = None
    
    
    def GetAttributeValue(self, attribute, index):
        """
         Resolves the given attribute name
        
         :returns: The attribute value or null if it could not be found
         :param attribute: The requested attribute name
         :param index: The index of this attribute
        """
        if attribute == 'INPUT':
            return self.Input
        return super(Transition, self).GetAttributeValue(attribute, index)
    
    
    def SetFeature(self, feature, value):
        """
         Sets a value to the given feature
        
         :param feature: The requested feature
         :param value: The value that should be set to that feature
        """
        if feature == 'STARTSTATE':
            self.StartState = value
            return 
        if feature == 'ENDSTATE':
            self.EndState = value
            return 
        if feature == 'INPUT':
            self.Input = value
            return 
        super(Transition, self).SetFeature(feature, value)
    
    
    class TransitionReferencedElementsCollection(ReferenceCollection,CollectionExpression,Collection):
        """type(__parent) == Transition"""
        
        @staticmethod
        def _typeOfPARENT():
            return Transition
        
        def __init__(self, parent):
            super(TransitionReferencedElementsCollection, self).__init__()
            self._ConstructorFieldInitFunction()
            self.__parent = parent
        
        
        """Gets the amount of elements contained in this collection"""
        def get_Count(self):
            count = 0
            if self.__parent.StartState != None:
                count = count + 1
            if self.__parent.EndState != None:
                count = count + 1
            return count
        
        Count = property(fget=get_Count,doc="""Gets the amount of elements contained in this collection""")
        
        
        def AttachCore(self):
            self.__parent.StartStateChanged += self.PropagateValueChanges
            self.__parent.EndStateChanged += self.PropagateValueChanges
        
        
        def DetachCore(self):
            self.__parent.StartStateChanged -= self.PropagateValueChanges
            self.__parent.EndStateChanged -= self.PropagateValueChanges
        
        
        def Add(self, item):
            """
             Adds the given element to the collection
            
             :param item: The item to add
            """
            if self.__parent.StartState is None:
                startStateCasted = item.As()
                if startStateCasted != None:
                    self.__parent.StartState = startStateCasted
                    return 
            if self.__parent.EndState is None:
                endStateCasted = item.As()
                if endStateCasted != None:
                    self.__parent.EndState = endStateCasted
                    return 
        
        
        def Clear(self):
            """Clears the collection and resets all references that implement it."""
            self.__parent.StartState = None
            self.__parent.EndState = None
        
        
        def Contains(self, item):
            """
             Gets a value indicating whether the given element is contained in the collection
            
             :returns: True, if it is contained, otherwise False
             :param item: The item that should be looked out for
            """
            if item is self.__parent.StartState:
                return True
            if item is self.__parent.EndState:
                return True
            return False
        
        
        def CopyTo(self, array, arrayIndex):
            """
             Copies the contents of the collection to the given array starting from the given array index
            
             :param array: The array in which the elements should be copied
             :param arrayIndex: The starting index
            """
            if self.__parent.StartState != None:
                array[arrayIndex] = self.__parent.StartState
                arrayIndex = arrayIndex + 1
            if self.__parent.EndState != None:
                array[arrayIndex] = self.__parent.EndState
                arrayIndex = arrayIndex + 1
        
        
        def Remove(self, item):
            """
             Removes the given item from the collection
            
             :returns: True, if the item was removed, otherwise False
             :param item: The item that should be removed
            """
            if self.__parent.StartState is item:
                self.__parent.StartState = None
                return True
            if self.__parent.EndState is item:
                self.__parent.EndState = None
                return True
            return False
        
        
        def GetEnumerator(self):
            """
             Gets an enumerator that enumerates the collection
            
             :returns: A generic enumerator
            """
            return Enumerable.Empty().Concat(self.__parent.StartState).Concat(self.__parent.EndState).GetEnumerator()
        
        def _ConstructorFieldInitFunction(self):
            self.__parent = None
    
    def _ConstructorFieldInitFunction(self):
        self.__input = None
        self.InputChanging = EventHandler()
        self.InputChanged = EventHandler()
        self.__startState = None
        self.StartStateChanging = EventHandler()
        self.StartStateChanged = EventHandler()
        self.__endState = None
        self.EndStateChanging = EventHandler()
        self.EndStateChanged = EventHandler()


class StateTransitionsCollection(ObservableOppositeOrderedSet):
    
    def __init__(self, parent):
        super(StateTransitionsCollection, self).__init__(parent)
    
    
    def _OnItemDeleted(self, sender, e):
        self.Remove(sender)
    
    
    def SetOpposite(self, item, parent):
        if parent != None:
            item.Deleted += self._OnItemDeleted
            item.StartState = parent
        else:
            item.Deleted -= self._OnItemDeleted
            if item.StartState is self.Parent:
                item.StartState = parent
    

def CreateFromDocument(xml_text):
    """Parse the given XML and use the document element to create a
    Python instance.
    
    @param xml_text An XML document.  This should be data (Python 2
    str), or a text (Python 2 unicode)"""
    types = [FiniteStateMachine, State, Transition, StateTransitionsCollection]
    return deserialize(xml_text, types)