001/* Copyright (C) 2013 TU Dortmund
002 * This file is part of AutomataLib, http://www.automatalib.net/.
003 * 
004 * AutomataLib is free software; you can redistribute it and/or
005 * modify it under the terms of the GNU Lesser General Public
006 * License version 3.0 as published by the Free Software Foundation.
007 * 
008 * AutomataLib is distributed in the hope that it will be useful,
009 * but WITHOUT ANY WARRANTY; without even the implied warranty of
010 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
011 * Lesser General Public License for more details.
012 * 
013 * You should have received a copy of the GNU Lesser General Public
014 * License along with AutomataLib; if not, see
015 * http://www.gnu.de/documents/lgpl.en.html.
016 */
017package net.automatalib.util.ts;
018
019import java.util.Collection;
020import java.util.Iterator;
021
022import net.automatalib.commons.util.mappings.Mapping;
023import net.automatalib.ts.DeterministicTransitionSystem;
024import net.automatalib.ts.TransitionSystem;
025import net.automatalib.ts.UniversalTransitionSystem;
026import net.automatalib.util.ts.TSIterators.AllTransitionsIterator;
027import net.automatalib.util.ts.TSIterators.DefinedTransitionsIterator;
028import net.automatalib.util.ts.TSIterators.UndefinedTransitionsIterator;
029import net.automatalib.util.ts.traversal.BFSOrderIterator;
030
031
032public abstract class TS {
033        
034        public static final class TransRef<S,I> {
035                public final S state;
036                public final I input;
037                public TransRef(S state, I input) {
038                        this.state = state;
039                        this.input = input;
040                }
041        }
042        
043        public static <S,I,T> Iterable<T> allTransitions(final TransitionSystem<S,I,T> ts,
044                        final S state,
045                        final Collection<I> inputs) {
046                return new Iterable<T>() {
047                        @Override
048                        public Iterator<T> iterator() {
049                                return new AllTransitionsIterator<S,I,T>(ts, state, inputs);
050                        }
051                };
052        }
053        
054        public static <S,I> Iterable<S> bfsOrder(final TransitionSystem<S,I,?> ts, final Collection<? extends I> inputs) {
055                return new Iterable<S>() {
056                        @Override
057                        public Iterator<S> iterator() {
058                                return new BFSOrderIterator<S, I>(ts, inputs);
059                        }
060                        
061                };
062        }
063        
064        public static <S,SP> Mapping<S,SP> stateProperties(final UniversalTransitionSystem<S, ?, ?, SP, ?> uts) {
065                return new Mapping<S,SP>() {
066                        @Override
067                        public SP get(S elem) {
068                                return uts.getStateProperty(elem);
069                        }
070                };
071        }
072        
073        public static <T,TP> Mapping<T,TP> transitionProperties(final UniversalTransitionSystem<?, ?, T, ?, TP> uts) {
074                return new Mapping<T,TP>() {
075                        @Override
076                        public TP get(T elem) {
077                                return uts.getTransitionProperty(elem);
078                        }
079                };
080        }
081        
082        public static <S,I> Iterator<I> definedTransitionsIterator(DeterministicTransitionSystem<S, I, ?> dts,
083                        S state,
084                        Iterator<? extends I> inputsIt) {
085                return new DefinedTransitionsIterator<S, I>(dts, state, inputsIt);
086        }
087        
088        public static <S,I> Iterable<I> definedTransitions(
089                        final DeterministicTransitionSystem<S, I, ?> dts,
090                        final S state,
091                        final Iterable<? extends I> inputs) {
092                return new Iterable<I>() {
093                        @Override
094                        public Iterator<I> iterator() {
095                                return definedTransitionsIterator(dts, state, inputs.iterator());
096                        }
097                };
098        }
099        
100        public static <S,I> Iterator<TransRef<S,I>> allDefinedTransitionsIterator(
101                        DeterministicTransitionSystem<S, I, ?> dts,
102                        Iterator<? extends S> stateIt,
103                        Iterable<? extends I> inputs) {
104                return new TSIterators.AllDefinedTransitionsIterator<>(stateIt, dts, inputs);
105        }
106        
107        public static <S,I> Iterable<TransRef<S,I>> allDefinedTransitions(
108                        final DeterministicTransitionSystem<S, I, ?> dts,
109                        final Iterable<? extends S> states,
110                        final Iterable<? extends I> inputs) {
111                return new Iterable<TransRef<S,I>>() {
112                        @Override
113                        public Iterator<TransRef<S, I>> iterator() {
114                                return allDefinedTransitionsIterator(dts, states.iterator(), inputs);
115                        }
116                };
117        }
118        
119        
120        
121        public static <S,I> Iterator<I> undefinedTransitionsIterator(DeterministicTransitionSystem<S, I, ?> dts,
122                        S state,
123                        Iterator<? extends I> inputsIt) {
124                return new UndefinedTransitionsIterator<S, I>(dts, state, inputsIt);
125        }
126        
127        public static <S,I> Iterable<I> undefinedTransitions(
128                        final DeterministicTransitionSystem<S, I, ?> dts,
129                        final S state,
130                        final Iterable<? extends I> inputs) {
131                return new Iterable<I>() {
132                        @Override
133                        public Iterator<I> iterator() {
134                                return undefinedTransitionsIterator(dts, state, inputs.iterator());
135                        }
136                };
137        }
138        
139        public static <S,I> Iterator<TransRef<S,I>> allUndefinedTransitionsIterator(
140                        DeterministicTransitionSystem<S, I, ?> dts,
141                        Iterator<? extends S> stateIt,
142                        Iterable<? extends I> inputs) {
143                return new TSIterators.AllUndefinedTransitionsIterator<>(stateIt, dts, inputs);
144        }
145        
146        public static <S,I> Iterable<TransRef<S,I>> allUndefinedTransitions(
147                        final DeterministicTransitionSystem<S, I, ?> dts,
148                        final Iterable<? extends S> states,
149                        final Iterable<? extends I> inputs) {
150                return new Iterable<TransRef<S,I>>() {
151                        @Override
152                        public Iterator<TransRef<S, I>> iterator() {
153                                return allUndefinedTransitionsIterator(dts, states.iterator(), inputs);
154                        }
155                };
156        }
157        
158}