Package owl.automaton

## Class AutomatonFactory

- java.lang.Object
- - owl.automaton.AutomatonFactory

-     public final class AutomatonFactory
      extends Object

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `create​(ValuationSetFactory factory, Collection<S> initialStates, A acceptance, BiFunction<S,BitSet,? extends Collection<Edge<S>>> edgesFunction, Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)` | Creates a non-deterministic on-the-fly constructed automaton with support for bulk creation of edges.
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `create​(ValuationSetFactory factory, Collection<S> initialStates, A acceptance, BiFunction<S,BitSet,Edge<S>> transitions)` | Creates a semi-deterministic on-the-fly constructed automaton.
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `create​(ValuationSetFactory factory, Collection<S> initialStates, A acceptance, Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)` | Creates a non-deterministic on-the-fly constructed automaton with supporting only bulk creation of edges.
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `create​(ValuationSetFactory factory, S initialState, A acceptance, BiFunction<S,BitSet,? extends Collection<Edge<S>>> edgesFunction, Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)` | Creates a non-deterministic on-the-fly constructed automaton with support for bulk creation of edges.
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `create​(ValuationSetFactory factory, S initialState, A acceptance, BiFunction<S,BitSet,Edge<S>> transitions)` | Creates a deterministic on-the-fly constructed automaton.
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `create​(ValuationSetFactory factory, S initialState, A acceptance, Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)` | Creates a non-deterministic on-the-fly constructed automaton with supporting only bulk creation of edges.
    `static <S> Automaton<S,NoneAcceptance>` | `empty​(ValuationSetFactory factory)` |
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `singleton​(ValuationSetFactory factory, S state, A acceptance)` |
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `singleton​(ValuationSetFactory factory, S state, A acceptance, BitSet acceptanceSet)` |
    `static <S,A extends OmegaAcceptance> Automaton<S,A>` | `singleton​(ValuationSetFactory factory, S state, A acceptance, Set<Integer> acceptanceSet)` |

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

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

- - ### Method Detail

    - #### create

          public static <S,A extends OmegaAcceptance> Automaton<S,A> create​(ValuationSetFactory factory,
                                                                            S initialState,
                                                                            A acceptance,
                                                                            BiFunction<S,BitSet,Edge<S>> transitions)

      Creates a deterministic on-the-fly constructed automaton.
      Type Parameters:
        `S` - The type of the state.
        `A` - The type of the acceptance conditions.
      Parameters:
        `factory` - The alphabet.
        `initialState` - The initial state.
        `acceptance` - The acceptance condition.
        `transitions` - The transition function.

    - #### create

          public static <S,A extends OmegaAcceptance> Automaton<S,A> create​(ValuationSetFactory factory,
                                                                            Collection<S> initialStates,
                                                                            A acceptance,
                                                                            BiFunction<S,BitSet,Edge<S>> transitions)

      Creates a semi-deterministic on-the-fly constructed automaton.
      Type Parameters:
        `S` - The type of the state.
        `A` - The type of the acceptance conditions.
      Parameters:
        `factory` - The alphabet.
        `initialStates` - The initial state.
        `acceptance` - The acceptance condition.
        `transitions` - The transition function.

    - #### create

          public static <S,A extends OmegaAcceptance> Automaton<S,A> create​(ValuationSetFactory factory,
                                                                            S initialState,
                                                                            A acceptance,
                                                                            Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)

      Creates a non-deterministic on-the-fly constructed automaton with supporting only bulk creation of edges.
      Type Parameters:
        `S` - The type of the state.
        `A` - The type of the acceptance conditions.
      Parameters:
        `factory` - The alphabet.
        `initialState` - The initial state.
        `acceptance` - The acceptance condition.
        `labelledEdgesFunction` - A bulk transition function, needs to be consistent with `transitions`.

    - #### create

          public static <S,A extends OmegaAcceptance> Automaton<S,A> create​(ValuationSetFactory factory,
                                                                            S initialState,
                                                                            A acceptance,
                                                                            BiFunction<S,BitSet,? extends Collection<Edge<S>>> edgesFunction,
                                                                            Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)

      Creates a non-deterministic on-the-fly constructed automaton with support for bulk creation of edges.
      Type Parameters:
        `S` - The type of the state.
        `A` - The type of the acceptance conditions.
      Parameters:
        `factory` - The alphabet.
        `initialState` - The initial state.
        `acceptance` - The acceptance condition.
        `edgesFunction` - The transition function.
        `labelledEdgesFunction` - A bulk transition function, needs to be consistent with `transitions`.

    - #### create

          public static <S,A extends OmegaAcceptance> Automaton<S,A> create​(ValuationSetFactory factory,
                                                                            Collection<S> initialStates,
                                                                            A acceptance,
                                                                            Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)

      Creates a non-deterministic on-the-fly constructed automaton with supporting only bulk creation of edges.
      Type Parameters:
        `S` - The type of the state.
        `A` - The type of the acceptance conditions.
      Parameters:
        `factory` - The alphabet.
        `initialStates` - The initial states.
        `acceptance` - The acceptance condition.
        `labelledEdgesFunction` - A bulk transition function, needs to be consistent with `transitions`.

    - #### create

          public static <S,A extends OmegaAcceptance> Automaton<S,A> create​(ValuationSetFactory factory,
                                                                            Collection<S> initialStates,
                                                                            A acceptance,
                                                                            BiFunction<S,BitSet,? extends Collection<Edge<S>>> edgesFunction,
                                                                            Function<S,? extends Collection<LabelledEdge<S>>> labelledEdgesFunction)

      Creates a non-deterministic on-the-fly constructed automaton with support for bulk creation of edges.
      Type Parameters:
        `S` - The type of the state.
        `A` - The type of the acceptance conditions.
      Parameters:
        `factory` - The alphabet.
        `initialStates` - The initial states.
        `acceptance` - The acceptance condition.
        `edgesFunction` - The transition function.
        `labelledEdgesFunction` - A bulk transition function, needs to be consistent with `transitions`.

    - #### empty

          public static <S> Automaton<S,NoneAcceptance> empty​(ValuationSetFactory factory)

    - #### singleton

          public static <S,A extends OmegaAcceptance> Automaton<S,A> singleton​(ValuationSetFactory factory,
                                                                               S state,
                                                                               A acceptance)

    - #### singleton

          public static <S,A extends OmegaAcceptance> Automaton<S,A> singleton​(ValuationSetFactory factory,
                                                                               S state,
                                                                               A acceptance,
                                                                               Set<Integer> acceptanceSet)

    - #### singleton

          public static <S,A extends OmegaAcceptance> Automaton<S,A> singleton​(ValuationSetFactory factory,
                                                                               S state,
                                                                               A acceptance,
                                                                               BitSet acceptanceSet)