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,​Set<Edge<S>>> edgesFunction, Function<S,​? extends Map<Edge<S>,​ValuationSet>> 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,​Map<Edge<S>,​ValuationSet>> 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,​Set<Edge<S>>> edgesFunction, Function<S,​Map<Edge<S>,​ValuationSet>> 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,​Map<Edge<S>,​ValuationSet>> 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>` | `empty​(ValuationSetFactory factory, A acceptance)` |
    `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,​Map<Edge<S>,​ValuationSet>> 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,​Set<Edge<S>>> edgesFunction,
                                                                                        Function<S,​Map<Edge<S>,​ValuationSet>> 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,​Map<Edge<S>,​ValuationSet>> 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,​Set<Edge<S>>> edgesFunction,
                                                                                        Function<S,​? extends Map<Edge<S>,​ValuationSet>> 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)

    - #### empty

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

    - #### 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)