Package com.saxonica.ee.schema.fsa

## Class AutomatonState

- java.lang.Object
- - com.saxonica.ee.schema.fsa.AutomatonState

- All Implemented Interfaces:
    `State`
  Direct Known Subclasses:
    `DeterminizedState`, `NonDeterminizedState`

      public abstract class AutomatonState
      extends java.lang.Object
      implements State

  Defines a state of a finite state machine used when validating an instance against a complex type. Each State knows about the possible transitions to other states, and knows whether it is a final state. The initial state is referenced from the FiniteStateMachine object, which is itself a property of the UserComplexType against which validation is being performed.

  This class is designed for internal use only.

- - ### Field Summary

    Fields
    Modifier and Type | Field | Description
    --- | --- | ---
    `static Edge[]` | `EMPTY_EDGE_ARRAY` |
    `protected Edge[]` | `wildcardEdges` |

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `AutomatonState​(FiniteStateMachine machine)` | Create a new state

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `void` | `addSpecificTransition​(Edge edge, SchemaCompiler compiler)` | Add a specific transition from this state to another state.
    `void` | `addWildcardTransition​(SchemaCompiler compiler, Edge transition)` | Add a wildcard transition from this state to another state.
    `void` | `display​(java.util.HashMap<AutomatonState,​java.lang.Integer> map)` | Display the finite state machine reachable from this state.
    `void` | `displayLambdaTransitions()` | Display the lambda transitions available from this state
    `void` | `displayState​(Logger err)` | Display the finite state machine reachable from this state.
    `java.util.Iterator<Edge>` | `getEdges()` | Get an iterator over all the transitions (edges) allowed from this state
    `Edge` | `getMaxTransition()` | Get the transition to be used when the maxOccurs value is reached for a counting state.
    `int` | `getStateNumber()` | Get the state number
    `Edge` | `getTransition​(int token, UserComplexType type)` | Find the edge representing the transition from this state to another state, that is triggered by a given input token
    `Edge[]` | `getWildcardEdges()` | Get an iterator over the wildcard transitions (edges) allowed from this state.
    `boolean` | `isConditionallyFinalState()` | Test whether this state is a final state assuming the counter has reached its minimum value
    `boolean` | `isFinalState()` | Test whether this state is a final state
    `java.lang.CharSequence` | `listAllowedElements()` | List the allowed elements in this state as a string, for use in error messages
    `boolean` | `requiresCounter()` | Ask whether this is a counting state
    `void` | `serialize​(SchemaModelSerializer serializer)` | Serialize this state as part of the serialization of a schema component model
    `void` | `setFinalState​(boolean finalState)` | Set this state to be (or not to be) a final state
    `void` | `setLimits​(int min, int max)` | Set the counter limits
    `void` | `setMaxTransition​(Edge edge)` | A counting state may have a special Edge that is used when the maxOccurs value is reached.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### wildcardEdges

          protected Edge[] wildcardEdges

    - #### EMPTY_EDGE_ARRAY

          public static final Edge[] EMPTY_EDGE_ARRAY

  - ### Constructor Detail

    - #### AutomatonState

          public AutomatonState​(FiniteStateMachine machine)

      Create a new state
      Parameters:
        `machine` - the finite state machine to which this State belongs

  - ### Method Detail

    - #### isFinalState

          public boolean isFinalState()

      Test whether this state is a final state
      Specified by:
        `isFinalState` in interface `State`
      Returns:
        true if this is a final state

    - #### isConditionallyFinalState

          public boolean isConditionallyFinalState()

      Test whether this state is a final state assuming the counter has reached its minimum value
      Returns:
        true if this state is a final state when the minimum number of occurrences is reached

    - #### setFinalState

          public void setFinalState​(boolean finalState)

      Set this state to be (or not to be) a final state
      Parameters:
        `finalState` - true if this state is final

    - #### getStateNumber

          public int getStateNumber()

      Get the state number
      Returns:
        the state number

    - #### addSpecificTransition

          public void addSpecificTransition​(Edge edge,
                                            SchemaCompiler compiler)
                                     throws SchemaException

      Add a specific transition from this state to another state. This transition accepts a specific element name only.
      Parameters:
        `edge` - the transition to be added
        `compiler` - the schema compiler
      Throws:
        `SchemaException` - if there are two transitions for the same element declaration, that is, if the content model is ambiguous

    - #### addWildcardTransition

          public void addWildcardTransition​(SchemaCompiler compiler,
                                            Edge transition)
                                     throws SchemaException

      Add a wildcard transition from this state to another state.
      Parameters:
        `compiler` - the schema compiler
        `transition` - the edge representing the transition
      Throws:
        `SchemaException` - if the transition cannot be added because it would generate an inconsistency

    - #### setLimits

          public void setLimits​(int min,
                                int max)

      Set the counter limits
      Parameters:
        `min` - the minimum number of occurrences of counting edges before a non-counting edge is used
        `max` - the maximum number of occurrences of counting edges before a non-counting edge is used; the value -1 means unbounded

    - #### requiresCounter

          public boolean requiresCounter()

      Ask whether this is a counting state
      Returns:
        true if this state requires a counter to be maintained

    - #### getTransition

          public Edge getTransition​(int token,
                                    UserComplexType type)

      Find the edge representing the transition from this state to another state, that is triggered by a given input token
      Specified by:
        `getTransition` in interface `State`
      Parameters:
        `token` - the input token, specifically the fingerprint of an element name
        `type` - the complex type we are validating against
      Returns:
        the Edge representing the selected transition of the finite state machine, or null if this token is not accepted when in this State (which implies a validation error).

    - #### listAllowedElements

          public java.lang.CharSequence listAllowedElements()

      List the allowed elements in this state as a string, for use in error messages
      Specified by:
        `listAllowedElements` in interface `State`
      Returns:
        the list of permitted elements as a string containing comma-separated element names

    - #### getWildcardEdges

          public Edge[] getWildcardEdges()

      Get an iterator over the wildcard transitions (edges) allowed from this state.
      Specified by:
        `getWildcardEdges` in interface `State`
      Returns:
        an Iterator over the edges that represent element wildcards. The objects returned by this Iterator are `Edge` objects.

    - #### getEdges

          public java.util.Iterator<Edge> getEdges()

      Get an iterator over all the transitions (edges) allowed from this state
      Specified by:
        `getEdges` in interface `State`
      Returns:
        an Iterator over all the edges from this state. The objects returned by this Iterator are `Edge` objects.

    - #### display

          public void display​(java.util.HashMap<AutomatonState,​java.lang.Integer> map)

      Display the finite state machine reachable from this state. This is a diagnostic method for internal use. Output is written to System.err. At present, wildcard transitions are not shown.
      Parameters:
        `map` - a Hashmap mapping states already processed to the integer values used to represent that state. The method should be called initially with an empty map.

    - #### displayState

          public void displayState​(Logger err)

      Display the finite state machine reachable from this state. This is a diagnostic method for internal use. Output is written to System.err. At present, wildcard transitions are not shown.
      Parameters:
        `err` - the output destination destination

    - #### displayLambdaTransitions

          public void displayLambdaTransitions()

      Display the lambda transitions available from this state

    - #### setMaxTransition

          public void setMaxTransition​(Edge edge)

      A counting state may have a special Edge that is used when the maxOccurs value is reached. This method sets this edge.
      Parameters:
        `edge` - the transition to be used when the maxOccurs value is reached

    - #### getMaxTransition

          public Edge getMaxTransition()

      Get the transition to be used when the maxOccurs value is reached for a counting state.
      Returns:
        the max transition if there is one, else null.

    - #### serialize

          public void serialize​(SchemaModelSerializer serializer)
                         throws XPathException

      Serialize this state as part of the serialization of a schema component model
      Parameters:
        `serializer` - used to output the model
      Throws:
        `XPathException` - if any failure occurs