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}