java.lang.Object
- net.automatalib.util.automaton.copy.AutomatonLowLevelCopy

public final class AutomatonLowLevelCopy
extends Object

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method	Description
`static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I,T1,? extends SP,? extends TP> in, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP,? super TP> out)`	Copies a `UniversalAutomaton` with compatible input alphabets and properties.
`static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I,T1,? extends SP,? extends TP> in, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP,? super TP> out, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I,? super T1> transFilter)`	Copies a `UniversalAutomaton` with compatible input alphabets and properties.
`static <S1,I,T1,SP1,TP1,S2,T2,SP2,TP2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I,T1,? extends SP1,? extends TP1> in, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform)`	Copies a `UniversalAutomaton` to a `MutableAutomaton` with compatible input alphabets, but possibly heterogeneous properties.
`static <S1,I,T1,SP1,TP1,S2,T2,SP2,TP2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I,T1,? extends SP1,? extends TP1> in, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I,? super T1> transFilter)`	Copies a `UniversalAutomaton` to a `MutableAutomaton` with compatible input alphabets, but possibly heterogeneous properties.
`static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I1,T1,? extends SP,? extends TP> in, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP,? super TP> out, Function<? super I1,? extends I2> inputsMapping)`	Copies a `UniversalAutomaton` with possibly heterogeneous input alphabets, but compatible properties.
`static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I1,T1,? extends SP,? extends TP> in, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP,? super TP> out, Function<? super I1,? extends I2> inputsMapping, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I1,? super T1> transFilter)`	Copies a `UniversalAutomaton` with possibly heterogeneous input alphabets, but compatible properties.
`static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I1,T1,? extends SP1,? extends TP1> in, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform)`	Copies a `UniversalAutomaton` to a `MutableAutomaton` with possibly heterogeneous input alphabets and state and transition properties.
`static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>`	`copy(AutomatonCopyMethod method, UniversalAutomaton<S1,? super I1,T1,? extends SP1,? extends TP1> in, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super SP1,? extends SP2> spTransform, Function<? super TP1,? extends TP2> tpTransform, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I1,? super T1> transFilter)`	Copies a `UniversalAutomaton` to a `MutableAutomaton` with possibly heterogeneous input alphabets and state and transition properties.
`static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2>`	`rawCopy(AutomatonCopyMethod method, Automaton<S1,? super I,T1> in, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,SP2,TP2> out, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping)`	Copies an `Automaton` to a `MutableAutomaton` with a compatible input alphabet, but possibly heterogeneous state and transition properties.
`static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2>`	`rawCopy(AutomatonCopyMethod method, Automaton<S1,? super I,T1> in, Collection<? extends I> inputs, MutableAutomaton<S2,I,T2,SP2,TP2> out, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I,? super T1> transFilter)`	Copies an `Automaton` to a `MutableAutomaton` with a compatible input alphabet, but possibly heterogeneous state and transition properties.
`static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>`	`rawCopy(AutomatonCopyMethod method, Automaton<S1,? super I1,T1> in, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping)`	Copies an `Automaton` to a `MutableAutomaton` with possibly heterogeneous input alphabets and state and transition properties.
`static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2>`	`rawCopy(AutomatonCopyMethod method, Automaton<S1,? super I1,T1> in, Collection<? extends I1> inputs, MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out, Function<? super I1,? extends I2> inputsMapping, Function<? super S1,? extends SP2> spMapping, Function<? super T1,? extends TP2> tpMapping, Predicate<? super S1> stateFilter, TransitionPredicate<? super S1,? super I1,? super T1> transFilter)`	Copies an `Automaton` to a `MutableAutomaton` with possibly heterogeneous input alphabets and state and transition properties.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

rawCopy

public static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(AutomatonCopyMethod method,
                                                                                                                 Automaton<S1,? super I1,T1> in,
                                                                                                                 Collection<? extends I1> inputs,
                                                                                                                 MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                                                                 Function<? super I1,? extends I2> inputsMapping,
                                                                                                                 Function<? super S1,? extends SP2> spMapping,
                                                                                                                 Function<? super T1,? extends TP2> tpMapping)

Copies an Automaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties. State and transitions will not be filtered.

Type Parameters:: S1 - input automaton state type; I1 - input automaton input symbol type; T1 - input automaton transition type; S2 - output automaton state type; I2 - output automaton input symbol type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; inputsMapping - the transformation for input symbols; spMapping - the function for obtaining state properties; tpMapping - the function for obtaining transition properties
Returns:: a mapping from old to new states

rawCopy

public static <S1,I1,T1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(AutomatonCopyMethod method,
                                                                                                                 Automaton<S1,? super I1,T1> in,
                                                                                                                 Collection<? extends I1> inputs,
                                                                                                                 MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                                                                 Function<? super I1,? extends I2> inputsMapping,
                                                                                                                 Function<? super S1,? extends SP2> spMapping,
                                                                                                                 Function<? super T1,? extends TP2> tpMapping,
                                                                                                                 Predicate<? super S1> stateFilter,
                                                                                                                 TransitionPredicate<? super S1,? super I1,? super T1> transFilter)

Copies an Automaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.

Type Parameters:: S1 - input automaton state type; I1 - input automaton input symbol type; T1 - input automaton transition type; S2 - output automaton state type; I2 - output automaton input symbol type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; inputsMapping - the transformation for input symbols; spMapping - the function for obtaining state properties; tpMapping - the function for obtaining transition properties; stateFilter - the filter predicate for states; transFilter - the filter predicate for transitions
Returns:: a mapping from old to new states

rawCopy

public static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(AutomatonCopyMethod method,
                                                                                                       Automaton<S1,? super I,T1> in,
                                                                                                       Collection<? extends I> inputs,
                                                                                                       MutableAutomaton<S2,I,T2,SP2,TP2> out,
                                                                                                       Function<? super S1,? extends SP2> spMapping,
                                                                                                       Function<? super T1,? extends TP2> tpMapping)

Copies an Automaton to a MutableAutomaton with a compatible input alphabet, but possibly heterogeneous state and transition properties. States and transitions will not be filtered.

Type Parameters:: S1 - input automaton state type; I - input symbol type; T1 - input automaton transition type; S2 - output automaton state type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; spMapping - the function for obtaining state properties; tpMapping - the function for obtaining transition properties
Returns:: a mapping from old to new states

rawCopy

public static <S1,I,T1,S2,T2,SP2,TP2> Mapping<S1,S2> rawCopy(AutomatonCopyMethod method,
                                                                                                       Automaton<S1,? super I,T1> in,
                                                                                                       Collection<? extends I> inputs,
                                                                                                       MutableAutomaton<S2,I,T2,SP2,TP2> out,
                                                                                                       Function<? super S1,? extends SP2> spMapping,
                                                                                                       Function<? super T1,? extends TP2> tpMapping,
                                                                                                       Predicate<? super S1> stateFilter,
                                                                                                       TransitionPredicate<? super S1,? super I,? super T1> transFilter)

Copies an Automaton to a MutableAutomaton with a compatible input alphabet, but possibly heterogeneous state and transition properties.

Type Parameters:: S1 - input automaton state type; I - input symbol type; T1 - input automaton transition type; S2 - output automaton state type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; spMapping - the function for obtaining state properties; tpMapping - the function for obtaining transition properties; stateFilter - the filter predicate for states; transFilter - the filter predicate for transitions
Returns:: a mapping from old to new states

copy

public static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                                                  UniversalAutomaton<S1,? super I1,T1,? extends SP1,? extends TP1> in,
                                                                                                                                  Collection<? extends I1> inputs,
                                                                                                                                  MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                                                                                  Function<? super I1,? extends I2> inputsMapping,
                                                                                                                                  Function<? super SP1,? extends SP2> spTransform,
                                                                                                                                  Function<? super TP1,? extends TP2> tpTransform)

Copies a UniversalAutomaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties. States and transitions will not be filtered

Type Parameters:: S1 - input automaton state type; I1 - input automaton input symbol type; T1 - input automaton transition type; SP1 - input automaton state property type; TP1 - input automaton transition property type; S2 - output automaton state type; I2 - output automaton input symbol type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; inputsMapping - the transformation for input symbols; spTransform - the transformation for state properties; tpTransform - the transformation for transition properties
Returns:: a mapping from old to new states

copy

public static <S1,I1,T1,SP1,TP1,S2,I2,T2,SP2,TP2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                                                  UniversalAutomaton<S1,? super I1,T1,? extends SP1,? extends TP1> in,
                                                                                                                                  Collection<? extends I1> inputs,
                                                                                                                                  MutableAutomaton<S2,I2,T2,? super SP2,? super TP2> out,
                                                                                                                                  Function<? super I1,? extends I2> inputsMapping,
                                                                                                                                  Function<? super SP1,? extends SP2> spTransform,
                                                                                                                                  Function<? super TP1,? extends TP2> tpTransform,
                                                                                                                                  Predicate<? super S1> stateFilter,
                                                                                                                                  TransitionPredicate<? super S1,? super I1,? super T1> transFilter)

Copies a UniversalAutomaton to a MutableAutomaton with possibly heterogeneous input alphabets and state and transition properties.

Type Parameters:: S1 - input automaton state type; I1 - input automaton input symbol type; T1 - input automaton transition type; SP1 - input automaton state property type; TP1 - input automaton transition property type; S2 - output automaton state type; I2 - output automaton input symbol type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; inputsMapping - the transformation for input symbols; spTransform - the transformation for state properties; tpTransform - the transformation for transition properties; stateFilter - the filter predicate for states; transFilter - the filter predicate for transitions
Returns:: a mapping from old to new states

copy

public static <S1,I,T1,SP1,TP1,S2,T2,SP2,TP2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                                        UniversalAutomaton<S1,? super I,T1,? extends SP1,? extends TP1> in,
                                                                                                                        Collection<? extends I> inputs,
                                                                                                                        MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out,
                                                                                                                        Function<? super SP1,? extends SP2> spTransform,
                                                                                                                        Function<? super TP1,? extends TP2> tpTransform)

Copies a UniversalAutomaton to a MutableAutomaton with compatible input alphabets, but possibly heterogeneous properties. States and transitions will not be filtered.

Type Parameters:: S1 - input automaton state type; I - input symbol type; T1 - input automaton transition type; SP1 - input automaton state property type; TP1 - input automaton transition property type; S2 - output automaton state type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; spTransform - the transformation for state properties; tpTransform - the transformation for transition properties
Returns:: a mapping from old to new states

copy

public static <S1,I,T1,SP1,TP1,S2,T2,SP2,TP2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                                        UniversalAutomaton<S1,? super I,T1,? extends SP1,? extends TP1> in,
                                                                                                                        Collection<? extends I> inputs,
                                                                                                                        MutableAutomaton<S2,I,T2,? super SP2,? super TP2> out,
                                                                                                                        Function<? super SP1,? extends SP2> spTransform,
                                                                                                                        Function<? super TP1,? extends TP2> tpTransform,
                                                                                                                        Predicate<? super S1> stateFilter,
                                                                                                                        TransitionPredicate<? super S1,? super I,? super T1> transFilter)

Copies a UniversalAutomaton to a MutableAutomaton with compatible input alphabets, but possibly heterogeneous properties.

Type Parameters:: S1 - input automaton state type; I - input symbol type; T1 - input automaton transition type; SP1 - input automaton state property type; TP1 - input automaton transition property type; S2 - output automaton state type; T2 - output automaton transition type; SP2 - output automaton state property type; TP2 - output automaton transition property type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; spTransform - the transformation for state properties; tpTransform - the transformation for transition properties; stateFilter - the filter predicate for states; transFilter - the filter predicate for transitions
Returns:: a mapping from old to new states

copy

public static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                            UniversalAutomaton<S1,? super I1,T1,? extends SP,? extends TP> in,
                                                                                                            Collection<? extends I1> inputs,
                                                                                                            MutableAutomaton<S2,I2,T2,? super SP,? super TP> out,
                                                                                                            Function<? super I1,? extends I2> inputsMapping)

Copies a UniversalAutomaton with possibly heterogeneous input alphabets, but compatible properties. States and transitions will not be filtered

Type Parameters:: S1 - input automaton state type; I1 - input automaton input symbol type; T1 - input automaton transition type; SP - state property type; TP - transition property type; S2 - output automaton state type; I2 - output automaton input symbol type; T2 - output automaton transition type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; inputsMapping - a mapping from inputs in the input automaton to inputs in the output automaton
Returns:: a mapping from old to new states

copy

public static <S1,I1,T1,SP,TP,S2,I2,T2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                            UniversalAutomaton<S1,? super I1,T1,? extends SP,? extends TP> in,
                                                                                                            Collection<? extends I1> inputs,
                                                                                                            MutableAutomaton<S2,I2,T2,? super SP,? super TP> out,
                                                                                                            Function<? super I1,? extends I2> inputsMapping,
                                                                                                            Predicate<? super S1> stateFilter,
                                                                                                            TransitionPredicate<? super S1,? super I1,? super T1> transFilter)

Copies a UniversalAutomaton with possibly heterogeneous input alphabets, but compatible properties.

Type Parameters:: S1 - input automaton state type; I1 - input automaton input symbol type; T1 - input automaton transition type; SP - state property type; TP - transition property type; S2 - output automaton state type; I2 - output automaton input symbol type; T2 - output automaton transition type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; inputsMapping - the transformation for input symbols; stateFilter - the filter predicate for states; transFilter - the filter predicate for transitions
Returns:: a mapping from old to new states

copy

public static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                  UniversalAutomaton<S1,? super I,T1,? extends SP,? extends TP> in,
                                                                                                  Collection<? extends I> inputs,
                                                                                                  MutableAutomaton<S2,I,T2,? super SP,? super TP> out)

Copies a UniversalAutomaton with compatible input alphabets and properties. States and transitions will not be filtered.

Type Parameters:: S1 - input automaton state type; I - input symbol type; T1 - input automaton transition type; SP - state property type; TP - transition property type; S2 - output automaton state type; T2 - output automaton transition type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton
Returns:: a mapping from old to new states.

copy

public static <S1,I,T1,SP,TP,S2,T2> Mapping<S1,S2> copy(AutomatonCopyMethod method,
                                                                                                  UniversalAutomaton<S1,? super I,T1,? extends SP,? extends TP> in,
                                                                                                  Collection<? extends I> inputs,
                                                                                                  MutableAutomaton<S2,I,T2,? super SP,? super TP> out,
                                                                                                  Predicate<? super S1> stateFilter,
                                                                                                  TransitionPredicate<? super S1,? super I,? super T1> transFilter)

Copies a UniversalAutomaton with compatible input alphabets and properties.

Type Parameters:: S1 - input automaton state type; I - input symbol type; T1 - input automaton transition type; SP - state property type; TP - transition property type; S2 - output automaton state type; T2 - output automaton transition type
Parameters:: method - the copy method to use; in - the input automaton; inputs - the inputs to consider; out - the output automaton; stateFilter - the filter predicate for states; transFilter - the filter predicate for transitions
Returns:: a mapping from old to new states

Class AutomatonLowLevelCopy

Method Summary

Methods inherited from class java.lang.Object

Method Detail

rawCopy

rawCopy

rawCopy

rawCopy

copy

copy

copy

copy

copy

copy

copy

copy