Package owl.automaton

## Class TwoPartAutomaton<A,​B,​C extends OmegaAcceptance>

- java.lang.Object
- - owl.automaton.AbstractCachedStatesAutomaton<Either<A,​B>,​C>
  - - owl.automaton.TwoPartAutomaton<A,​B,​C>

- All Implemented Interfaces:
    `Automaton<Either<A,​B>,​C>`, `EdgeTreeAutomatonMixin<Either<A,​B>,​C>`

      public abstract class TwoPartAutomaton<A,​B,​C extends OmegaAcceptance>
      extends AbstractCachedStatesAutomaton<Either<A,​B>,​C>
      implements EdgeTreeAutomatonMixin<Either<A,​B>,​C>

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from interface owl.automaton.Automaton

      `Automaton.EdgeMapVisitor<S>, Automaton.EdgeTreeVisitor<S>, Automaton.EdgeVisitor<S>, Automaton.PreferredEdgeAccess, Automaton.Property, Automaton.Visitor<S>`

  - ### Field Summary

    - ### Fields inherited from interface owl.automaton.EdgeTreeAutomatonMixin

      `ACCESS_MODES`

  - ### Constructor Summary

    Constructors
    Constructor | Description
    --- | ---
    `TwoPartAutomaton()` |

  - ### Method Summary

    All Methods Instance Methods Abstract Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `protected Set<Edge<Either<A,​B>>>` | `deduplicate​(Set<Edge<Either<A,​B>>> edges)` |
    `Set<Edge<Either<A,​B>>>` | `edges​(Either<A,​B> state, BitSet valuation)` | Returns the successor edges of the specified `state` under the given `valuation`.
    `protected Set<Edge<A>>` | `edgesA​(A state, BitSet valuation)` |
    `protected Set<Edge<B>>` | `edgesB​(B state, BitSet valuation)` |
    `ValuationTree<Edge<Either<A,​B>>>` | `edgeTree​(Either<A,​B> state)` | Returns a decision-tree with nodes labelled by literals and sets of edges as leaves.
    `protected abstract ValuationTree<Edge<A>>` | `edgeTreeA​(A state)` |
    `protected abstract ValuationTree<Edge<B>>` | `edgeTreeB​(B state)` |
    `Set<Either<A,​B>>` | `initialStates()` | Returns the set of initial states, which can potentially be empty.
    `protected abstract Set<A>` | `initialStatesA()` |
    `protected abstract Set<B>` | `initialStatesB()` |
    `protected abstract Set<B>` | `moveAtoB​(A state)` |

    - ### Methods inherited from class owl.automaton.AbstractCachedStatesAutomaton

      `accept, accept, accept, cache, states`

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

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

    - ### Methods inherited from interface owl.automaton.Automaton

      `accept, accept, accept, accept, acceptance, edge, factory, is, name, onlyInitialState, predecessors, size, states, successor, successors, successors`

    - ### Methods inherited from interface owl.automaton.EdgeTreeAutomatonMixin

      `edgeMap, edges, preferredEdgeAccess`

- - ### Constructor Detail

    - #### TwoPartAutomaton

          public TwoPartAutomaton()

  - ### Method Detail

    - #### initialStates

          public final Set<Either<A,​B>> initialStates()

      Description copied from interface: `Automaton`
      Returns the set of initial states, which can potentially be empty.
      Specified by:
        `initialStates` in interface `Automaton<A,​B>`
      Returns:
        The set of initial states.

    - #### edges

          public final Set<Edge<Either<A,​B>>> edges​(Either<A,​B> state,
                                                          BitSet valuation)

      Description copied from interface: `Automaton`
      Returns the successor edges of the specified `state` under the given `valuation`.
      Specified by:
        `edges` in interface `Automaton<A,​B>`
      Specified by:
        `edges` in interface `EdgeTreeAutomatonMixin<A,​B>`
      Parameters:
        `state` - The starting state of the transition.
        `valuation` - The valuation.
      Returns:
        The successor edges, possibly empty.

    - #### edgeTree

          public final ValuationTree<Edge<Either<A,​B>>> edgeTree​(Either<A,​B> state)

      Description copied from interface: `Automaton`
      Returns a decision-tree with nodes labelled by literals and sets of edges as leaves.
      Specified by:
        `edgeTree` in interface `Automaton<A,​B>`
      Parameters:
        `state` - The state.
      Returns:
        A tree.

    - #### initialStatesA

          protected abstract Set<A> initialStatesA()

    - #### initialStatesB

          protected abstract Set<B> initialStatesB()

    - #### edgesA

          protected Set<Edge<A>> edgesA​(A state,
                                        BitSet valuation)

    - #### edgesB

          protected Set<Edge<B>> edgesB​(B state,
                                        BitSet valuation)

    - #### edgeTreeA

          protected abstract ValuationTree<Edge<A>> edgeTreeA​(A state)

    - #### edgeTreeB

          protected abstract ValuationTree<Edge<B>> edgeTreeB​(B state)

    - #### moveAtoB

          protected abstract Set<B> moveAtoB​(A state)

    - #### deduplicate

          protected Set<Edge<Either<A,​B>>> deduplicate​(Set<Edge<Either<A,​B>>> edges)