/usr/include/fst/fst-decl.h is in libfst-dev 1.6.3-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 | // See www.openfst.org for extensive documentation on this weighted
// finite-state transducer library.
//
// This file contains declarations of classes in the Fst template library.
#ifndef FST_LIB_FST_DECL_H_
#define FST_LIB_FST_DECL_H_
#include <sys/types.h>
#include <memory> // for allocator<>
#include <fst/types.h>
namespace fst {
// Symbol table and iterator.
class SymbolTable;
class SymbolTableIterator;
// Weight templates and weights.
template <class T>
class FloatWeightTpl;
template <class T>
class TropicalWeightTpl;
template <class T>
class LogWeightTpl;
template <class T>
class MinMaxWeightTpl;
using FloatWeight = FloatWeightTpl<float>;
using TropicalWeight = TropicalWeightTpl<float>;
using LogWeight = LogWeightTpl<float>;
using MinMaxWeight = MinMaxWeightTpl<float>;
// Arc templates and arcs.
template <class Weight>
struct ArcTpl;
using StdArc = ArcTpl<TropicalWeight>;
using LogArc = ArcTpl<LogWeight>;
// Stores.
template <class Element, class U>
class DefaultCompactStore;
template <class Arc>
class DefaultCacheStore;
// FST templates.
template <class Arc, class Compactor, class U = uint32,
class CompactStore = DefaultCompactStore<typename Compactor::Element, U>,
class CacheStore = DefaultCacheStore<Arc>>
class CompactFst;
template <class Arc, class U = uint32>
class ConstFst;
template <class Arc, class Weight, class Matcher>
class EditFst;
template <class Arc>
class ExpandedFst;
template <class Arc>
class Fst;
template <class Arc>
class MutableFst;
template <class Arc, class Allocator = std::allocator<Arc>>
class VectorState;
template <class Arc, class State = VectorState<Arc>>
class VectorFst;
template <class Arc, class U = ssize_t>
class DefaultReplaceStateTable;
// On-the-fly operations.
template <class Arc, class Compare>
class ArcSortFst;
template <class Arc>
class ClosureFst;
template <class Arc, class Store = DefaultCacheStore<Arc>>
class ComposeFst;
template <class Arc>
class ConcatFst;
template <class Arc>
class DeterminizeFst;
template <class Arc>
class DifferenceFst;
template <class Arc>
class IntersectFst;
template <class Arc>
class InvertFst;
template <class AArc, class BArc, class Mapper>
class ArcMapFst;
template <class Arc>
class ProjectFst;
template <class AArc, class BArc, class Selector>
class RandGenFst;
template <class Arc>
class RelabelFst;
template <class Arc, class StateTable = DefaultReplaceStateTable<Arc>,
class Store = DefaultCacheStore<Arc>>
class ReplaceFst;
template <class Arc>
class RmEpsilonFst;
template <class Arc>
class UnionFst;
// Heap.
template <class T, class Compare>
class Heap;
// Compactors.
template <class Arc>
class AcceptorCompactor;
template <class Arc>
class StringCompactor;
template <class Arc>
class UnweightedAcceptorCompactor;
template <class Arc>
class UnweightedCompactor;
template <class Arc>
class WeightedStringCompactor;
// Compact FSTs.
template <class Arc, class U = uint32>
using CompactStringFst = CompactFst<Arc, StringCompactor<Arc>, U>;
template <class Arc, class U = uint32>
using CompactWeightedStringFst =
CompactFst<Arc, WeightedStringCompactor<Arc>, U>;
template <class Arc, class U = uint32>
using CompactAcceptorFst = CompactFst<Arc, AcceptorCompactor<Arc>, U>;
template <class Arc, class U = uint32>
using CompactUnweightedFst = CompactFst<Arc, UnweightedCompactor<Arc>, U>;
template <class Arc, class U = uint32>
using CompactUnweightedAcceptorFst =
CompactFst<Arc, UnweightedAcceptorCompactor<Arc>, U>;
// StdArc aliases for FSTs.
using StdConstFst = ConstFst<StdArc>;
using StdExpandedFst = ExpandedFst<StdArc>;
using StdFst = Fst<StdArc>;
using StdMutableFst = MutableFst<StdArc>;
using StdVectorFst = VectorFst<StdArc>;
// StdArc aliases for on-the-fly operations.
template <class Compare>
using StdArcSortFst = ArcSortFst<StdArc, Compare>;
using StdClosureFst = ClosureFst<StdArc>;
using StdComposeFst = ComposeFst<StdArc>;
using StdConcatFst = ConcatFst<StdArc>;
using StdDeterminizeFst = DeterminizeFst<StdArc>;
using StdDifferenceFst = DifferenceFst<StdArc>;
using StdIntersectFst = IntersectFst<StdArc>;
using StdInvertFst = InvertFst<StdArc>;
using StdProjectFst = ProjectFst<StdArc>;
using StdRelabelFst = RelabelFst<StdArc>;
using StdReplaceFst = ReplaceFst<StdArc>;
using StdRmEpsilonFst = RmEpsilonFst<StdArc>;
using StdUnionFst = UnionFst<StdArc>;
// Filter states.
template <class T>
class IntegerFilterState;
using CharFilterState = IntegerFilterState<signed char>;
using ShortFilterState = IntegerFilterState<short>; // NOLINT
using IntFilterState = IntegerFilterState<int>;
// Matchers and filters.
template <class FST>
class Matcher;
template <class Matcher1, class Matcher2 = Matcher1>
class NullComposeFilter;
template <class Matcher1, class Matcher2 = Matcher1>
class TrivialComposeFilter;
template <class Matcher1, class Matcher2 = Matcher1>
class SequenceComposeFilter;
template <class Matcher1, class Matcher2 = Matcher1>
class AltSequenceComposeFilter;
template <class Matcher1, class Matcher2 = Matcher1>
class MatchComposeFilter;
} // namespace fst
#endif // FST_LIB_FST_DECL_H_
|