FST  openfst-1.8.1
OpenFst Library
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
fst Namespace Reference

Namespaces

 internal
 
 script
 

Classes

class  AcceptorCompactor
 
class  Adder
 
class  Adder< ExpectationWeight< W1, W2 > >
 
class  Adder< LogWeightTpl< T > >
 
class  Adder< ProductWeight< W1, W2 > >
 
class  Adder< RealWeightTpl< T > >
 
class  Adder< SignedLogWeightTpl< T > >
 
class  AddOnPair
 
class  AlgoTester
 
class  AltSequenceComposeFilter
 
class  AnyArcFilter
 
class  ArcArena
 
class  ArcArenaStateStore
 
class  ArcIterator
 
class  ArcIterator< ArcMapFst< A, B, C > >
 
class  ArcIterator< ArcSortFst< Arc, Compare > >
 
class  ArcIterator< ClosureFst< Arc > >
 
class  ArcIterator< CompactFst< Arc, Compactor, CacheStore > >
 
class  ArcIterator< ComplementFst< Arc > >
 
class  ArcIterator< ComposeFst< Arc, CacheStore > >
 
class  ArcIterator< ConcatFst< Arc > >
 
class  ArcIterator< ConstFst< Arc, Unsigned > >
 
class  ArcIterator< DecodeFst< Arc > >
 
class  ArcIterator< DeterminizeFst< Arc > >
 
class  ArcIterator< DifferenceFst< Arc > >
 
class  ArcIterator< EncodeFst< Arc > >
 
class  ArcIterator< FactorWeightFst< Arc, FactorIterator > >
 
class  ArcIterator< IntersectFst< Arc > >
 
class  ArcIterator< InvertFst< Arc > >
 
class  ArcIterator< LinearClassifierFst< Arc > >
 
class  ArcIterator< LinearTaggerFst< Arc > >
 
class  ArcIterator< MatcherFst< FST, M, Name, Init > >
 
class  ArcIterator< MPdtExpandFst< Arc > >
 
class  ArcIterator< NGramFst< A > >
 
class  ArcIterator< PdtExpandFst< Arc > >
 
class  ArcIterator< ProjectFst< A > >
 
class  ArcIterator< RandGenFst< FromArc, ToArc, Sampler > >
 
class  ArcIterator< RationalFst< Arc > >
 
class  ArcIterator< RelabelFst< Arc > >
 
class  ArcIterator< ReplaceFst< Arc, StateTable, CacheStore > >
 
class  ArcIterator< RmEpsilonFst< Arc > >
 
class  ArcIterator< StateMapFst< A, B, C > >
 
class  ArcIterator< SynchronizeFst< Arc > >
 
class  ArcIterator< UnionFst< Arc > >
 
class  ArcIterator< VectorFst< Arc, State > >
 
class  ArcIteratorBase
 
struct  ArcIteratorData
 
class  ArcLookAheadMatcher
 
class  ArcMapFst
 
struct  ArcMapFstOptions
 
class  ArcSampler
 
class  ArcSampler< Arc, FastLogProbArcSelector< Arc > >
 
class  ArcSortFst
 
class  ArcSortMapper
 
class  ArcSumMapper
 
struct  ArcTpl
 
class  ArcUniqueMapper
 
class  AStarWeightCompare
 
class  AutoQueue
 
class  BitmapIndex
 
class  BlockAllocator
 
class  CacheArcIterator
 
struct  CacheImplOptions
 
class  CacheLogAccumulator
 
class  CacheLogAccumulatorData
 
class  CacheMutableArcIterator
 
struct  CacheOptions
 
class  CacheState
 
class  CacheStateIterator
 
class  CcVisitor
 
class  CheckSummer
 
class  ClosureFst
 
struct  ClosureFstOptions
 
class  Collection
 
class  CompactArcCompactor
 
class  CompactArcState
 
class  CompactArcState< ArcCompactor, U, CompactArcStore< typename ArcCompactor::Element, U > >
 
class  CompactArcStore
 
class  CompactFst
 
struct  CompactFstOptions
 
class  CompactHashBiTable
 
class  CompactHashStateTable
 
class  CompactSet
 
class  ComplementFst
 
class  ComposeFingerprint
 
class  ComposeFst
 
struct  ComposeFstImplOptions
 
class  ComposeFstMatcher
 
struct  ComposeFstOptions
 
class  ComposeHash
 
struct  ComposeOptions
 
class  ComposeState1Fingerprint
 
class  ComposeState2Fingerprint
 
class  CompositeWeightReader
 
class  CompositeWeightWriter
 
class  Compressor
 
class  ConcatFst
 
class  ConstFst
 
class  CopyVisitor
 
class  DecodeFst
 
class  DefaultAccumulator
 
class  DefaultCacheStore
 
struct  DefaultCommonDivisor
 
class  DefaultComposeStateTuple
 
class  DefaultComposeStateTuple< S, TrivialFilterState >
 
class  DefaultDeterminizeFilter
 
class  DefaultDeterminizeStateTable
 
class  DefaultLookAhead
 
class  DefaultLookAhead< Arc, MATCH_INPUT >
 
class  DefaultLookAhead< Arc, MATCH_OUTPUT >
 
class  DefaultLookAhead< LogArc, MATCH_INPUT >
 
class  DefaultLookAhead< LogArc, MATCH_OUTPUT >
 
class  DefaultLookAhead< StdArc, MATCH_INPUT >
 
class  DefaultLookAhead< StdArc, MATCH_OUTPUT >
 
class  DefaultReplaceStateTable
 
class  DeterminizeFst
 
struct  DeterminizeFstOptions
 
struct  DeterminizeOptions
 
class  DetStringComposeStateTable
 
class  DifferenceFst
 
struct  DifferenceFstOptions
 
struct  DisambiguateOptions
 
class  EditFst
 
class  Elias
 
class  EncodeFst
 
class  EncodeMapper
 
class  EncodeTableHeader
 
class  EpsilonArcFilter
 
class  EpsMapper
 
class  ErasableBiTable
 
class  ErasableComposeStateTable
 
class  ErasableStateTable
 
struct  ErrorWeight
 
class  ExpandedFst
 
class  ExpanderCacheStore
 
struct  ExpectationArc
 
class  ExpectationWeight
 
class  ExplicitMatcher
 
class  FactorWeightFst
 
struct  FactorWeightOptions
 
class  FarHeader
 
struct  FarInfoData
 
class  FarReader
 
class  FarWriter
 
class  FastLogAccumulator
 
class  FastLogAccumulatorData
 
class  FastLogProbArcSelector
 
class  FeatureGroup
 
class  FeatureGroupBuilder
 
class  FifoQueue
 
class  FilterQueue
 
class  FirstCacheStore
 
class  FlatTrieTopology
 
class  FloatLimits
 
class  FloatWeightGenerate
 
class  FloatWeightTpl
 
class  FromGallicMapper
 
class  FromPowerWeightMapper
 
class  Fst
 
class  FstCompiler
 
class  FstDrawer
 
class  FstFarReader
 
class  FstFarWriter
 
class  FstHeader
 
class  FstInfo
 
class  FstPrinter
 
class  FstReader
 
struct  FstReadOptions
 
class  FstRegister
 
struct  FstRegisterEntry
 
class  FstRegisterer
 
class  FstTester
 
struct  FstWriteOptions
 
class  FstWriter
 
struct  GallicArc
 
class  GallicCommonDivisor
 
class  GallicCommonDivisor< Label, W, GALLIC, CommonDivisor >
 
class  GallicFactor
 
class  GallicFactor< Label, W, GALLIC >
 
class  GallicToNewSymbolsMapper
 
struct  GallicUnionWeightOptions
 
struct  GallicWeight
 
struct  GallicWeight< Label, W, GALLIC >
 
class  GCCacheStore
 
class  GenericComposeStateTable
 
class  GenericRegister
 
class  GenericRegisterer
 
class  HashBiTable
 
class  HashCacheStore
 
class  HashExpanderCache
 
class  HashMatcher
 
struct  HashSet
 
class  HashStateTable
 
class  Heap
 
class  IdentityArcMapper
 
class  IdentityFactor
 
class  IdentityStateMapper
 
class  ILabelCompare
 
class  ImplToExpandedFst
 
class  ImplToFst
 
class  ImplToMutableFst
 
class  InputEpsilonArcFilter
 
class  InputEpsilonMapper
 
class  IntegerFilterState
 
class  IntersectFst
 
struct  IntersectFstOptions
 
class  IntervalReachVisitor
 
class  IntervalSet
 
struct  IntInterval
 
class  InvertFst
 
struct  InvertMapper
 
class  InvertWeightMapper
 
class  iterator_range
 
struct  KeyInfo
 
class  LabelArcFilter
 
struct  LabelCommonDivisor
 
class  LabelLookAheadMatcher
 
class  LabelLookAheadRelabeler
 
class  LabelReachable
 
class  LabelReachableData
 
class  LempelZiv
 
struct  LexicographicArc
 
class  LexicographicWeight
 
class  LifoQueue
 
class  LinearClassifierFst
 
class  LinearClassifierFstDataBuilder
 
class  LinearFstData
 
class  LinearFstDataBuilder
 
class  LinearFstMatcherTpl
 
class  LinearTaggerFst
 
class  ListFilterState
 
class  LogAccumulator
 
class  LogProbArcSelector
 
class  LogWeightTpl
 
class  LookAheadComposeFilter
 
class  LookAheadMatcher
 
class  LookAheadMatcher< MatcherFst< F, M, Name, Init > >
 
class  LookAheadMatcherBase
 
class  LookAheadSelector
 
class  LookAheadSelector< Matcher, Matcher, MT >
 
class  LookAheadSelector< Matcher1, Matcher2, MATCH_INPUT >
 
class  LookAheadSelector< Matcher1, Matcher2, MATCH_OUTPUT >
 
class  MappedFile
 
class  MatchComposeFilter
 
class  Matcher
 
class  Matcher< MatcherFst< F, M, Name, Init > >
 
class  MatcherBase
 
class  MatcherFst
 
class  MemoryArenaBase
 
class  MemoryArenaCollection
 
class  MemoryPool
 
class  MemoryPoolBase
 
class  MemoryPoolCollection
 
struct  MemoryRegion
 
class  MinMaxWeightTpl
 
class  MPdtComposeFstOptions
 
class  MPdtComposeFstOptions< Arc, false >
 
struct  MPdtComposeOptions
 
class  MPdtExpandFst
 
struct  MPdtExpandFstOptions
 
struct  MPdtExpandOptions
 
class  MPdtInfo
 
class  MPdtParenFilter
 
class  MultiEpsFilter
 
class  MultiEpsMatcher
 
class  MultiLabelArcFilter
 
class  MutableArcIterator
 
class  MutableArcIterator< VectorFst< Arc, State > >
 
class  MutableArcIteratorBase
 
struct  MutableArcIteratorData
 
class  MutableFastLogAccumulatorData
 
class  MutableFst
 
class  MutableTrie
 
class  Mutex
 
class  MutexLock
 
class  NaturalAStarEstimate
 
class  NaturalAStarQueue
 
struct  NaturalLess
 
class  NaturalPruneQueue
 
class  NaturalShortestFirstQueue
 
class  NestedTrieTopology
 
class  NGramFst
 
struct  NGramFstInst
 
class  NGramFstMatcher
 
class  NoGcKeepOneExpanderCache
 
class  NoMatchComposeFilter
 
class  NullAddOn
 
class  NullComposeFilter
 
class  NullMatcherFstInit
 
class  OLabelCompare
 
class  OneFactor
 
class  OutputEpsilonArcFilter
 
class  OutputEpsilonMapper
 
class  PairFilterState
 
class  PairWeight
 
class  ParenFilter
 
class  ParenMatcher
 
struct  ParentLabel
 
struct  ParentLabelHash
 
class  PartialCopyVisitor
 
class  PartialVisitor
 
class  PdtComposeFstOptions
 
class  PdtComposeFstOptions< Arc, false >
 
struct  PdtComposeOptions
 
class  PdtExpandFst
 
struct  PdtExpandFstOptions
 
struct  PdtExpandOptions
 
class  PdtInfo
 
class  PdtLeftParser
 
class  PdtLeftSRParser
 
class  PdtParser
 
class  PdtPrunedExpand
 
struct  PdtReplaceOptions
 
class  PdtShortestPath
 
struct  PdtShortestPathOptions
 
class  PdtStack
 
class  PdtStateHash
 
class  PdtStateTable
 
struct  PdtStateTuple
 
class  PhiFstMatcher
 
class  PhiMatcher
 
class  PlusMapper
 
class  PoolAllocator
 
struct  PowerArc
 
class  PowerMapper
 
class  PowerWeight
 
struct  ProductArc
 
class  ProductComposeStateTable
 
class  ProductWeight
 
class  ProjectFst
 
class  ProjectMapper
 
class  ProjectPowerWeightMapper
 
class  PruneNaturalShortestFirstQueue
 
struct  PruneOptions
 
class  PruneQueue
 
class  PushLabelsComposeFilter
 
class  PushWeightsComposeFilter
 
class  QuantizeMapper
 
class  QueueBase
 
class  RandGenFst
 
struct  RandGenFstOptions
 
struct  RandGenOptions
 
struct  RandState
 
class  RationalFst
 
class  RealWeightTpl
 
class  RelabelFst
 
class  ReplaceAccumulator
 
class  ReplaceAccumulatorData
 
class  ReplaceFingerprint
 
class  ReplaceFst
 
class  ReplaceFstMatcher
 
struct  ReplaceFstOptions
 
class  ReplaceFstStateFingerprint
 
class  ReplaceHash
 
class  ReplaceRootSelector
 
class  ReplaceStackPrefix
 
class  ReplaceStackPrefixHash
 
struct  ReplaceStateTuple
 
class  ReplaceUtil
 
struct  ReplaceUtilOptions
 
struct  ReverseArc
 
class  ReverseWeightMapper
 
class  RhoFstMatcher
 
class  RhoMatcher
 
class  RmEpsilonFst
 
struct  RmEpsilonFstOptions
 
struct  RmEpsilonOptions
 
class  RmWeightMapper
 
class  SafeReplaceAccumulator
 
class  SccQueue
 
class  SccVisitor
 
class  SequenceComposeFilter
 
class  SetWeight
 
class  SetWeightIterator
 
struct  ShortestDistanceOptions
 
class  ShortestFirstQueue
 
struct  ShortestPathOptions
 
class  SigmaFstMatcher
 
class  SigmaMatcher
 
class  SignedLogWeightTpl
 
class  SimpleVectorCacheState
 
class  SortedMatcher
 
struct  SparsePowerArc
 
class  SparsePowerWeight
 
class  SparseTupleWeight
 
class  SparseTupleWeightIterator
 
class  StateIterator
 
class  StateIterator< ArcMapFst< A, B, C > >
 
class  StateIterator< ArcSortFst< Arc, Compare > >
 
class  StateIterator< ClosureFst< Arc > >
 
class  StateIterator< CompactFst< Arc, Compactor, CacheStore > >
 
class  StateIterator< ComplementFst< Arc > >
 
class  StateIterator< ComposeFst< Arc, CacheStore > >
 
class  StateIterator< ConcatFst< Arc > >
 
class  StateIterator< ConstFst< Arc, Unsigned > >
 
class  StateIterator< DecodeFst< Arc > >
 
class  StateIterator< DeterminizeFst< Arc > >
 
class  StateIterator< DifferenceFst< Arc > >
 
class  StateIterator< EncodeFst< Arc > >
 
class  StateIterator< FactorWeightFst< Arc, FactorIterator > >
 
class  StateIterator< IntersectFst< Arc > >
 
class  StateIterator< InvertFst< Arc > >
 
class  StateIterator< LinearClassifierFst< Arc > >
 
class  StateIterator< LinearTaggerFst< Arc > >
 
class  StateIterator< MatcherFst< FST, M, Name, Init > >
 
class  StateIterator< MPdtExpandFst< Arc > >
 
class  StateIterator< NGramFst< A > >
 
class  StateIterator< PdtExpandFst< Arc > >
 
class  StateIterator< ProjectFst< A > >
 
class  StateIterator< RandGenFst< FromArc, ToArc, Sampler > >
 
class  StateIterator< RationalFst< Arc > >
 
class  StateIterator< RelabelFst< Arc > >
 
class  StateIterator< ReplaceFst< Arc, StateTable, CacheStore > >
 
class  StateIterator< RmEpsilonFst< Arc > >
 
class  StateIterator< SynchronizeFst< Arc > >
 
class  StateIterator< UnionFst< Arc > >
 
class  StateIterator< VectorFst< Arc, State > >
 
class  StateIteratorBase
 
struct  StateIteratorData
 
class  StateMapFst
 
class  StateMapStateIteratorBase
 
class  StateOrderQueue
 
class  StateReachable
 
class  STListFarReader
 
class  STListFarWriter
 
class  STListReader
 
class  STListWriter
 
struct  StringArc
 
class  StringCompactor
 
class  StringCompiler
 
class  StringDetComposeStateTable
 
class  StringFactor
 
class  StringOrInt
 
class  StringPrinter
 
class  StringReader
 
class  StringWeight
 
class  StringWeightIterator
 
class  StringWeightReverseIterator
 
class  STTableFarReader
 
class  STTableFarWriter
 
class  STTableReader
 
class  STTableWriter
 
class  SuperFinalMapper
 
class  SymbolTable
 
struct  SymbolTableTextOptions
 
class  SynchronizeFst
 
class  TimesMapper
 
class  ToGallicMapper
 
class  TopOrderQueue
 
class  TopOrderVisitor
 
class  ToPowerWeightMapper
 
class  TransformPowerWeightMapper
 
class  TrivialArcCompactor
 
struct  TrivialAStarEstimate
 
class  TrivialCompactor
 
class  TrivialComposeFilter
 
class  TrivialFilterState
 
class  TrivialLookAheadMatcher
 
class  TrivialQueue
 
struct  TrivialStateEquivClass
 
class  TropicalWeightTpl
 
class  TupleWeight
 
class  UniformArcSelector
 
class  UnionFind
 
class  UnionFst
 
class  UnionWeight
 
class  UnionWeightIterator
 
class  UnionWeightReverseIterator
 
class  UnweightedAcceptorCompactor
 
class  UnweightedCompactor
 
class  UnweightedTester
 
class  UnweightedTester< StdArc >
 
class  VectorBiTable
 
class  VectorCacheStore
 
class  VectorExpanderCache
 
class  VectorFst
 
class  VectorHashBiTable
 
class  VectorHashReplaceStateTable
 
class  VectorHashStateTable
 
class  VectorIntervalStore
 
class  VectorState
 
class  VectorStateTable
 
class  WeightApproxEqual
 
struct  WeightConvert
 
struct  WeightConvert< Log64Weight, LogWeight >
 
struct  WeightConvert< Log64Weight, Real64Weight >
 
struct  WeightConvert< Log64Weight, RealWeight >
 
struct  WeightConvert< Log64Weight, SignedLog64Weight >
 
struct  WeightConvert< Log64Weight, SignedLogWeight >
 
struct  WeightConvert< Log64Weight, TropicalWeight >
 
struct  WeightConvert< LogWeight, Log64Weight >
 
struct  WeightConvert< LogWeight, Real64Weight >
 
struct  WeightConvert< LogWeight, RealWeight >
 
struct  WeightConvert< LogWeight, SignedLog64Weight >
 
struct  WeightConvert< LogWeight, SignedLogWeight >
 
struct  WeightConvert< LogWeight, TropicalWeight >
 
struct  WeightConvert< Real64Weight, Log64Weight >
 
struct  WeightConvert< Real64Weight, LogWeight >
 
struct  WeightConvert< Real64Weight, RealWeight >
 
struct  WeightConvert< Real64Weight, SignedLog64Weight >
 
struct  WeightConvert< Real64Weight, SignedLogWeight >
 
struct  WeightConvert< RealWeight, Log64Weight >
 
struct  WeightConvert< RealWeight, LogWeight >
 
struct  WeightConvert< RealWeight, Real64Weight >
 
struct  WeightConvert< RealWeight, SignedLog64Weight >
 
struct  WeightConvert< RealWeight, SignedLogWeight >
 
struct  WeightConvert< SetWeight< Label, S1 >, SetWeight< Label, S2 > >
 
struct  WeightConvert< SignedLog64Weight, Log64Weight >
 
struct  WeightConvert< SignedLog64Weight, LogWeight >
 
struct  WeightConvert< SignedLog64Weight, Real64Weight >
 
struct  WeightConvert< SignedLog64Weight, RealWeight >
 
struct  WeightConvert< SignedLog64Weight, SignedLogWeight >
 
struct  WeightConvert< SignedLog64Weight, TropicalWeight >
 
struct  WeightConvert< SignedLogWeight, Log64Weight >
 
struct  WeightConvert< SignedLogWeight, LogWeight >
 
struct  WeightConvert< SignedLogWeight, Real64Weight >
 
struct  WeightConvert< SignedLogWeight, RealWeight >
 
struct  WeightConvert< SignedLogWeight, SignedLog64Weight >
 
struct  WeightConvert< SignedLogWeight, TropicalWeight >
 
struct  WeightConvert< TropicalWeight, Log64Weight >
 
struct  WeightConvert< TropicalWeight, LogWeight >
 
struct  WeightConvert< TropicalWeight, SignedLog64Weight >
 
struct  WeightConvert< TropicalWeight, SignedLogWeight >
 
struct  WeightConvert< W, W >
 
class  WeightConvertMapper
 
class  WeightedStringCompactor
 
class  WeightedTester
 
class  WeightFilterState
 
struct  WeightGenerate
 
class  WeightGenerate< ExpectationWeight< W1, W2 > >
 
class  WeightGenerate< GallicWeight< Label, W, G > >
 
class  WeightGenerate< GallicWeight< Label, W, GALLIC > >
 
class  WeightGenerate< LexicographicWeight< W1, W2 > >
 
class  WeightGenerate< LogWeightTpl< T > >
 
class  WeightGenerate< MinMaxWeightTpl< T > >
 
class  WeightGenerate< PairWeight< W1, W2 > >
 
class  WeightGenerate< PowerWeight< W, n > >
 
class  WeightGenerate< ProductWeight< W1, W2 > >
 
class  WeightGenerate< RealWeightTpl< T > >
 
class  WeightGenerate< SetWeight< Label, S > >
 
class  WeightGenerate< SignedLogWeightTpl< T > >
 
class  WeightGenerate< SparsePowerWeight< W, K > >
 
class  WeightGenerate< StringWeight< Label, S > >
 
class  WeightGenerate< TropicalWeightTpl< T > >
 
class  WeightGenerate< UnionWeight< W, O > >
 
class  WeightTester
 

Typedefs

using StdToLogMapper = WeightConvertMapper< StdArc, LogArc >
 
using LogToStdMapper = WeightConvertMapper< LogArc, StdArc >
 
using StdToLog64Mapper = WeightConvertMapper< StdArc, Log64Arc >
 
using LogToLog64Mapper = WeightConvertMapper< LogArc, Log64Arc >
 
using Log64ToStdMapper = WeightConvertMapper< Log64Arc, StdArc >
 
using Log64ToLogMapper = WeightConvertMapper< Log64Arc, LogArc >
 
using StdArc = ArcTpl< TropicalWeight >
 
using LogArc = ArcTpl< LogWeight >
 
using Log64Arc = ArcTpl< Log64Weight >
 
using RealArc = ArcTpl< RealWeight >
 
using Real64Arc = ArcTpl< Real64Weight >
 
using SignedLogArc = ArcTpl< SignedLogWeight >
 
using SignedLog64Arc = ArcTpl< SignedLog64Weight >
 
using ErrorArc = ArcTpl< ErrorWeight >
 
using MinMaxArc = ArcTpl< MinMaxWeight >
 
using ArcSortFstOptions = CacheOptions
 
template<class Compare >
using StdArcSortFst = ArcSortFst< StdArc, Compare >
 
using StdILabelCompare = ILabelCompare< StdArc >
 
using StdOLabelCompare = OLabelCompare< StdArc >
 
using StdClosureFst = ClosureFst< StdArc >
 
template<class Arc , class Unsigned >
using CompactStringFst = CompactArcFst< Arc, StringCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactWeightedStringFst = CompactArcFst< Arc, WeightedStringCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactAcceptorFst = CompactArcFst< Arc, AcceptorCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactUnweightedFst = CompactArcFst< Arc, UnweightedCompactor< Arc >, Unsigned >
 
template<class Arc , class Unsigned >
using CompactUnweightedAcceptorFst = CompactArcFst< Arc, UnweightedAcceptorCompactor< Arc >, Unsigned >
 
using StdCompactStringFst = CompactStringFst< StdArc, uint32 >
 
using StdCompactWeightedStringFst = CompactWeightedStringFst< StdArc, uint32 >
 
using StdCompactAcceptorFst = CompactAcceptorFst< StdArc, uint32 >
 
using StdCompactUnweightedFst = CompactUnweightedFst< StdArc, uint32 >
 
using StdCompactUnweightedAcceptorFst = CompactUnweightedAcceptorFst< StdArc, uint32 >
 
using StdComplementFst = ComplementFst< StdArc >
 
using StdComposeFst = ComposeFst< StdArc >
 
using ConcatFstOptions = RationalFstOptions
 
using StdConcatFst = ConcatFst< StdArc >
 
using StdConstFst = ConstFst< StdArc >
 
using StdDeterminizeFst = DeterminizeFst< StdArc >
 
using DifferenceOptions = ComposeOptions
 
using StdDifferenceFst = DifferenceFst< StdArc >
 
using StdEncodeFst = EncodeFst< StdArc >
 
using StdDecodeFst = DecodeFst< StdArc >
 
using StdExpandedFst = ExpandedFst< StdArc >
 
template<class Expander >
using DefaultExpanderCache = VectorExpanderCache< typename Expander::Arc >
 
template<class Arc >
using PhiFst = MatcherFst< ConstFst< Arc >, PhiFstMatcher< SortedMatcher< ConstFst< Arc >>>, phi_fst_type >
 
using StdPhiFst = PhiFst< StdArc >
 
template<class Arc >
using InputPhiFst = MatcherFst< ConstFst< Arc >, PhiFstMatcher< SortedMatcher< ConstFst< Arc >>, kPhiFstMatchInput >, input_phi_fst_type >
 
using StdInputPhiFst = InputPhiFst< StdArc >
 
template<class Arc >
using OutputPhiFst = MatcherFst< ConstFst< Arc >, PhiFstMatcher< SortedMatcher< ConstFst< Arc >>, kPhiFstMatchOutput >, output_phi_fst_type >
 
using StdOutputPhiFst = OutputPhiFst< StdArc >
 
template<class Arc >
using RhoFst = MatcherFst< ConstFst< Arc >, RhoFstMatcher< SortedMatcher< ConstFst< Arc >>>, rho_fst_type >
 
using StdRhoFst = RhoFst< StdArc >
 
template<class Arc >
using InputRhoFst = MatcherFst< ConstFst< Arc >, RhoFstMatcher< SortedMatcher< ConstFst< Arc >>, kRhoFstMatchInput >, input_rho_fst_type >
 
using StdInputRhoFst = InputRhoFst< StdArc >
 
template<class Arc >
using OutputRhoFst = MatcherFst< ConstFst< Arc >, RhoFstMatcher< SortedMatcher< ConstFst< Arc >>, kRhoFstMatchOutput >, output_rho_fst_type >
 
using StdOutputRhoFst = OutputRhoFst< StdArc >
 
template<class Arc >
using SigmaFst = MatcherFst< ConstFst< Arc >, SigmaFstMatcher< SortedMatcher< ConstFst< Arc >>>, sigma_fst_type >
 
using StdSigmaFst = SigmaFst< StdArc >
 
template<class Arc >
using InputSigmaFst = MatcherFst< ConstFst< Arc >, SigmaFstMatcher< SortedMatcher< ConstFst< Arc >>, kSigmaFstMatchInput >, input_sigma_fst_type >
 
using StdInputSigmaFst = InputSigmaFst< StdArc >
 
template<class Arc >
using OutputSigmaFst = MatcherFst< ConstFst< Arc >, SigmaFstMatcher< SortedMatcher< ConstFst< Arc >>, kSigmaFstMatchOutput >, output_sigma_fst_type >
 
using StdOutputSigmaFst = OutputSigmaFst< StdArc >
 
using CharFilterState = IntegerFilterState< signed char >
 
using ShortFilterState = IntegerFilterState< short >
 
using IntFilterState = IntegerFilterState< int >
 
using FloatWeight = FloatWeightTpl< float >
 
using TropicalWeight = TropicalWeightTpl< float >
 
using LogWeight = LogWeightTpl< float >
 
using Log64Weight = LogWeightTpl< double >
 
using RealWeight = RealWeightTpl< float >
 
using Real64Weight = RealWeightTpl< double >
 
using MinMaxWeight = MinMaxWeightTpl< float >
 
template<class Arc , class ArcCompactor , class Unsigned = uint32, class CompactStore = CompactArcStore<typename ArcCompactor::Element, Unsigned>, class CacheStore = DefaultCacheStore<Arc>>
using CompactArcFst = CompactFst< Arc, CompactArcCompactor< ArcCompactor, Unsigned, CompactStore >, CacheStore >
 
using StdFst = Fst< StdArc >
 
using StdMutableFst = MutableFst< StdArc >
 
using StdVectorFst = VectorFst< 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 >
 
using IntersectOptions = ComposeOptions
 
using ReaderMutexLock = MutexLock
 
using instead = ArcMapFstOptions
 
using StdArcLookAheadFst = MatcherFst< ConstFst< StdArc >, ArcLookAheadMatcher< SortedMatcher< ConstFst< StdArc >>>, arc_lookahead_fst_type >
 
using StdILabelLookAheadFst = MatcherFst< ConstFst< StdArc >, LabelLookAheadMatcher< SortedMatcher< ConstFst< StdArc >>, ilabel_lookahead_flags, FastLogAccumulator< StdArc >>, ilabel_lookahead_fst_type, LabelLookAheadRelabeler< StdArc >>
 
using StdOLabelLookAheadFst = MatcherFst< ConstFst< StdArc >, LabelLookAheadMatcher< SortedMatcher< ConstFst< StdArc >>, olabel_lookahead_flags, FastLogAccumulator< StdArc >>, olabel_lookahead_fst_type, LabelLookAheadRelabeler< StdArc >>
 
template<typename T >
using MemoryArena = internal::MemoryArenaImpl< sizeof(T)>
 
using StdArcSelector = LogProbArcSelector< StdArc >
 
using RationalFstOptions = CacheOptions
 
using RelabelFstOptions = CacheOptions
 
template<class Arc >
using FstList = std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >>
 
using SignedLogWeight = SignedLogWeightTpl< float >
 
using SignedLog64Weight = SignedLogWeightTpl< double >
 
using StateMapFstOptions = CacheOptions
 
using StdArcSumMapper = ArcSumMapper< StdArc >
 
using StdArcUniqueMapper = ArcUniqueMapper< StdArc >
 
using StdStringCompiler = StringCompiler< StdArc >
 
using StdStringPrinter = StringPrinter< StdArc >
 
using SynchronizeFstOptions = CacheOptions
 
using UnionFstOptions = RationalFstOptions
 
template<class W >
using IsIdempotent = std::integral_constant< bool,(W::Properties()&kIdempotent)!=0 >
 
template<class W >
using IsPath = std::integral_constant< bool,(W::Properties()&kPath)!=0 >
 

Enumerations

enum  MapFinalAction { MAP_NO_SUPERFINAL, MAP_ALLOW_SUPERFINAL, MAP_REQUIRE_SUPERFINAL }
 
enum  MapSymbolsAction { MAP_CLEAR_SYMBOLS, MAP_COPY_SYMBOLS, MAP_NOOP_SYMBOLS }
 
enum  HSType { HS_STL, HS_FLAT }
 
enum  ComposeFilter {
  AUTO_FILTER, NULL_FILTER, TRIVIAL_FILTER, SEQUENCE_FILTER,
  ALT_SEQUENCE_FILTER, MATCH_FILTER, NO_MATCH_FILTER
}
 
enum  DeterminizeType { DETERMINIZE_FUNCTIONAL, DETERMINIZE_NONFUNCTIONAL, DETERMINIZE_DISAMBIGUATE }
 
enum  EncodeType { ENCODE = 1, DECODE = 2 }
 
enum  EpsNormalizeType { EPS_NORM_INPUT, EPS_NORM_OUTPUT }
 
enum  FarEntryType { FarEntryType::LINE, FarEntryType::FILE }
 
enum  FarType { FarType::DEFAULT = 0, FarType::STTABLE = 1, FarType::STLIST = 2, FarType::FST = 3 }
 
enum  MPdtType : uint8 { MPdtType::READ_RESTRICT, MPdtType::WRITE_RESTRICT, MPdtType::NO_RESTRICT }
 
enum  PdtComposeFilter : uint8 { PdtComposeFilter::PAREN, PdtComposeFilter::EXPAND, PdtComposeFilter::EXPAND_PAREN }
 
enum  PdtParserType : uint8 { PdtParserType::LEFT, PdtParserType::LEFT_SR }
 
enum  MatchType {
  MATCH_INPUT = 1, MATCH_OUTPUT = 2, MATCH_BOTH = 3, MATCH_NONE = 4,
  MATCH_UNKNOWN = 5
}
 
enum  MatcherRewriteMode { MATCHER_REWRITE_AUTO = 0, MATCHER_REWRITE_ALWAYS, MATCHER_REWRITE_NEVER }
 
enum  ProjectType { ProjectType::INPUT = 1, ProjectType::OUTPUT = 2 }
 
enum  QueueType {
  TRIVIAL_QUEUE = 0, FIFO_QUEUE = 1, LIFO_QUEUE = 2, SHORTEST_FIRST_QUEUE = 3,
  TOP_ORDER_QUEUE = 4, STATE_ORDER_QUEUE = 5, SCC_QUEUE = 6, AUTO_QUEUE = 7,
  OTHER_QUEUE = 8
}
 
enum  ClosureType { CLOSURE_STAR = 0, CLOSURE_PLUS = 1 }
 
enum  ReplaceLabelType { REPLACE_LABEL_NEITHER = 1, REPLACE_LABEL_INPUT = 2, REPLACE_LABEL_OUTPUT = 3, REPLACE_LABEL_BOTH = 4 }
 
enum  ReweightType { REWEIGHT_TO_INITIAL, REWEIGHT_TO_FINAL }
 
enum  SetType { SET_INTERSECT_UNION = 0, SET_UNION_INTERSECT = 1, SET_INTERSECT_UNION_RESTRICT = 2, SET_BOOLEAN = 3 }
 
enum  StringType { STRING_LEFT = 0, STRING_RIGHT = 1, STRING_RESTRICT = 2 }
 
enum  GallicType {
  GALLIC_LEFT = 0, GALLIC_RIGHT = 1, GALLIC_RESTRICT = 2, GALLIC_MIN = 3,
  GALLIC = 4
}
 
enum  TokenType : uint8 { TokenType::SYMBOL = 1, TokenType::BYTE = 2, TokenType::UTF8 = 3 }
 
enum  DivideType { DIVIDE_LEFT, DIVIDE_RIGHT, DIVIDE_ANY }
 

Functions

std::string GetFarTypeString (FarType far_type)
 
bool IsSTList (const std::string &source)
 
int KeySize (const char *source)
 
bool IsSTTable (const std::string &source)
 
uint32 nth_bit (const uint64 v, uint32 r)
 
 REGISTER_FST (PhiFst, StdArc)
 
 REGISTER_FST (PhiFst, LogArc)
 
 REGISTER_FST (PhiFst, Log64Arc)
 
 REGISTER_FST (InputPhiFst, StdArc)
 
 REGISTER_FST (InputPhiFst, LogArc)
 
 REGISTER_FST (InputPhiFst, Log64Arc)
 
 REGISTER_FST (OutputPhiFst, StdArc)
 
 REGISTER_FST (OutputPhiFst, LogArc)
 
 REGISTER_FST (OutputPhiFst, Log64Arc)
 
 REGISTER_FST (RhoFst, StdArc)
 
 REGISTER_FST (RhoFst, LogArc)
 
 REGISTER_FST (RhoFst, Log64Arc)
 
 REGISTER_FST (InputRhoFst, StdArc)
 
 REGISTER_FST (InputRhoFst, LogArc)
 
 REGISTER_FST (InputRhoFst, Log64Arc)
 
 REGISTER_FST (OutputRhoFst, StdArc)
 
 REGISTER_FST (OutputRhoFst, LogArc)
 
 REGISTER_FST (OutputRhoFst, Log64Arc)
 
 REGISTER_FST (SigmaFst, StdArc)
 
 REGISTER_FST (SigmaFst, LogArc)
 
 REGISTER_FST (SigmaFst, Log64Arc)
 
 REGISTER_FST (InputSigmaFst, StdArc)
 
 REGISTER_FST (InputSigmaFst, LogArc)
 
 REGISTER_FST (InputSigmaFst, Log64Arc)
 
 REGISTER_FST (OutputSigmaFst, StdArc)
 
 REGISTER_FST (OutputSigmaFst, LogArc)
 
 REGISTER_FST (OutputSigmaFst, Log64Arc)
 
template<class A , class C >
void ArcMap (MutableFst< A > *fst, C *mapper)
 
template<class A , class C >
void ArcMap (MutableFst< A > *fst, C mapper)
 
template<class A , class B , class C >
void ArcMap (const Fst< A > &ifst, MutableFst< B > *ofst, C *mapper)
 
template<class A , class B , class C >
void ArcMap (const Fst< A > &ifst, MutableFst< B > *ofst, C mapper)
 
template<class ArcMapper >
ArcMapFst< typename ArcMapper::FromArc, typename ArcMapper::ToArc, ArcMapper > MakeArcMapFst (const Fst< typename ArcMapper::FromArc > &fst, const ArcMapper &mapper)
 
template<class ArcMapper >
ArcMapFst< typename ArcMapper::FromArc, typename ArcMapper::ToArc, ArcMapper > MakeArcMapFst (const Fst< typename ArcMapper::FromArc > &fst, ArcMapper *mapper)
 
template<class Arc , class Compare >
void ArcSort (MutableFst< Arc > *fst, Compare comp)
 
template<class Arc >
void Closure (MutableFst< Arc > *fst, ClosureType closure_type)
 
template<class Arc >
void Closure (RationalFst< Arc > *fst, ClosureType closure_type)
 
template<class F , class G >
void Cast (const F &, G *)
 
template<class CompactArcFST , class FST >
bool WriteCompactArcFst (const FST &fst, const typename CompactArcFST::Compactor::ArcCompactor &arc_compactor, std::ostream &strm, const FstWriteOptions &opts)
 
template<class Arc , class Unsigned = uint32, class LabelIterator >
CompactStringFst< Arc, Unsigned > MakeCompactStringFst (const LabelIterator begin, const LabelIterator end)
 
template<class LabelIterator >
StdCompactStringFst MakeStdCompactStringFst (const LabelIterator begin, const LabelIterator end)
 
template<typename To , typename From >
To down_cast (From *f)
 
template<typename To , typename From >
To down_cast (From &f)
 
template<class Dest , class Source >
Dest bit_cast (const Source &source)
 
template<typename To >
constexpr To implicit_cast (typename internal::identity_t< To > to)
 
template<typename T >
std::unique_ptr< T > make_unique_for_overwrite ()
 
template<typename T >
std::unique_ptr< T[]> make_unique_for_overwrite (size_t n)
 
template<typename T >
std::unique_ptr< T > WrapUnique (T *ptr)
 
template<typename T >
iterator_range< T > make_range (T x, T y)
 
std::string StringJoin (const std::vector< std::string > &elements, const std::string &delim)
 
std::string StringJoin (const std::vector< std::string > &elements, const char *delim)
 
std::string StringJoin (const std::vector< std::string > &elements, char delim)
 
std::vector< std::string > StringSplit (const std::string &full, const std::string &delim)
 
std::vector< std::string > StringSplit (const std::string &full, const char *delim)
 
std::vector< std::string > StringSplit (const std::string &full, char delim)
 
void StripTrailingAsciiWhitespace (std::string *full)
 
std::string StripTrailingAsciiWhitespace (const std::string &full)
 
std::string StrCat (const StringOrInt &s1, const StringOrInt &s2)
 
std::string StrCat (const StringOrInt &s1, const StringOrInt &s2, const StringOrInt &s3)
 
std::string StrCat (const StringOrInt &s1, const StringOrInt &s2, const StringOrInt &s3, const StringOrInt &s4)
 
std::string StrCat (const StringOrInt &s1, const StringOrInt &s2, const StringOrInt &s3, const StringOrInt &s4, const StringOrInt &s5)
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const ComposeOptions &opts=ComposeOptions())
 
template<class Arc >
void Concat (MutableFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
void Concat (RationalFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
void Concat (const Fst< Arc > &fst1, MutableFst< Arc > *fst2)
 
template<class Arc >
void Concat (const std::vector< const Fst< Arc > * > &fsts1, MutableFst< Arc > *fst2)
 
template<class Arc >
void Concat (const Fst< Arc > &fst1, RationalFst< Arc > *fst2)
 
template<class Arc >
void Connect (MutableFst< Arc > *fst)
 
template<class Arc >
void Condense (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, std::vector< typename Arc::StateId > *scc)
 
template<class Arc >
void Determinize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, const DeterminizeOptions< Arc > &opts=DeterminizeOptions< Arc >())
 
template<class FST , class Visitor , class ArcFilter >
void DfsVisit (const FST &fst, Visitor *visitor, ArcFilter filter, bool access_only=false)
 
template<class Arc , class Visitor >
void DfsVisit (const Fst< Arc > &fst, Visitor *visitor)
 
template<class Arc >
void Difference (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const DifferenceOptions &opts=DifferenceOptions())
 
template<class Arc >
void Disambiguate (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, const DisambiguateOptions< Arc > &opts=DisambiguateOptions< Arc >())
 
template<class Arc >
void Encode (MutableFst< Arc > *fst, EncodeMapper< Arc > *mapper)
 
template<class Arc >
void Decode (MutableFst< Arc > *fst, const EncodeMapper< Arc > &mapper)
 
template<class Arc >
void EpsNormalize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, EpsNormalizeType type=EPS_NORM_INPUT)
 
template<class Arc , GallicType G>
void EpsNormalize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, EpsNormalizeType type)
 
template<class Arc , class WeightEqual >
bool Equal (const Fst< Arc > &fst1, const Fst< Arc > &fst2, WeightEqual weight_equal, uint8 etype=kEqualFsts)
 
template<class Arc >
bool Equal (const Fst< Arc > &fst1, const Fst< Arc > &fst2, float delta=kDelta, uint8 etype=kEqualFsts)
 
template<class Arc >
bool Equal (const Fst< Arc > &fst1, const Fst< Arc > &fst2, double delta, uint8 etype=kEqualFsts)
 
template<class Arc >
bool Equivalent (const Fst< Arc > &fst1, const Fst< Arc > &fst2, float delta=kDelta, bool *error=nullptr)
 
bool operator== (const ErrorWeight &, const ErrorWeight &)
 
bool operator!= (const ErrorWeight &, const ErrorWeight &)
 
bool ApproxEqual (const ErrorWeight &, const ErrorWeight &, float)
 
ErrorWeight Plus (const ErrorWeight &, const ErrorWeight &)
 
ErrorWeight Times (const ErrorWeight &, const ErrorWeight &)
 
ErrorWeight Divide (const ErrorWeight &, const ErrorWeight &)
 
std::ostream & operator<< (std::ostream &strm, const ErrorWeight &)
 
template<class Arc >
Arc::StateId CountStates (const Fst< Arc > &fst)
 
template<class Arc >
Arc::StateId CountStates (const std::vector< const Fst< Arc > * > &fsts)
 
template<class F >
size_t CountArcs (const F &fst)
 
template<class W1 , class W2 >
ExpectationWeight< W1, W2 > Plus (const ExpectationWeight< W1, W2 > &w1, const ExpectationWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
ExpectationWeight< W1, W2 > Times (const ExpectationWeight< W1, W2 > &w1, const ExpectationWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
ExpectationWeight< W1, W2 > Divide (const ExpectationWeight< W1, W2 > &w1, const ExpectationWeight< W1, W2 > &w2, DivideType typ)
 
template<class Arc >
void Compress (const Fst< Arc > &fst, std::ostream &strm)
 
template<class Arc >
bool Compress (const Fst< Arc > &fst, const std::string &source)
 
template<class Arc >
bool Decompress (std::istream &strm, const std::string &source, MutableFst< Arc > *fst)
 
template<class Arc >
bool Decompress (const std::string &source, MutableFst< Arc > *fst)
 
template<class Arc >
void FarCompileStrings (const std::vector< std::string > &in_sources, const std::string &out_source, const std::string &fst_type, const FarType &far_type, int32 generate_keys, FarEntryType entry_type, TokenType token_type, const std::string &symbols_source, const std::string &unknown_symbol, bool keep_symbols, bool initial_symbols, bool allow_negative_labels, const std::string &key_prefix, const std::string &key_suffix)
 
template<class Arc >
void FarConvert (const std::string &in_source, const std::string &out_source, const std::string &fst_type, const FarType &far_type)
 
template<class Arc >
void FarCreate (const std::vector< std::string > &in_sources, const std::string &out_source, const int32 generate_keys, const FarType &far_type, const std::string &key_prefix, const std::string &key_suffix)
 
template<class Arc >
bool FarEqual (const std::string &source1, const std::string &source2, float delta=kDelta, const std::string &begin_key=std::string(), const std::string &end_key=std::string())
 
template<class Arc >
void FarWriteFst (const Fst< Arc > *fst, std::string_view key, std::string *okey, int *nrep, int32 generate_sources, int i, std::string_view source_prefix, std::string_view source_suffix)
 
template<class Arc >
void FarExtract (const std::vector< std::string > &isources, int32 generate_sources, const std::string &keys, const std::string &key_separator, const std::string &range_delimiter, const std::string &source_prefix, const std::string &source_suffix)
 
bool IsFst (const std::string &source)
 
template<class Arc >
void AccumulateStatesAndArcs (const Fst< Arc > &fst, size_t *nstate, size_t *narc, size_t *nfinal)
 
template<class Arc >
void GetFarInfo (const std::vector< std::string > &sources, const std::string &begin_key, const std::string &end_key, const bool list_fsts, FarInfoData *far_info)
 
template<class Arc >
void FarInfo (const std::vector< std::string > &sources, const std::string &begin_key, const std::string &end_key, const bool list_fsts)
 
template<class Arc >
bool FarIsomorphic (const std::string &source1, const std::string &source2, float delta=kDelta, const std::string &begin_key=std::string(), const std::string &end_key=std::string())
 
template<class Arc >
void FarPrintStrings (const std::vector< std::string > &isources, FarEntryType entry_type, TokenType token_type, const std::string &begin_key, const std::string &end_key, bool print_key, bool print_weight, const std::string &symbols_source, bool initial_symbols, int32 generate_sources, const std::string &source_prefix, const std::string &source_suffix)
 
template<class Header >
bool ReadSTListHeader (const std::string &source, Header *header)
 
template<class Header >
bool ReadSTTableHeader (const std::string &source, Header *header)
 
std::string TranslateLabel (int64 label, const SymbolTable *syms)
 
template<class Iterator >
std::string JoinLabels (Iterator begin, Iterator end, const SymbolTable *syms)
 
template<class Label >
std::string JoinLabels (const std::vector< Label > &labels, const SymbolTable *syms)
 
template<class A >
A::Label GuessStartOrEnd (std::vector< typename A::Label > *sequence, typename A::Label boundary)
 
template<class A >
void LogLinearApply (const Fst< A > &ifst, const Fst< A > &lfst, MutableFst< A > *ofst, bool normalize=true)
 
template<class A , class B >
void LogLinearApply (const Fst< A > &ifst, const Fst< A > &lfst, MutableFst< A > *ofst, bool normalize=true)
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const MPdtComposeOptions &opts=MPdtComposeOptions())
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, MutableFst< Arc > *ofst, const MPdtComposeOptions &opts=MPdtComposeOptions())
 
uint64 MPdtExpandProperties (uint64 inprops)
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, MutableFst< Arc > *ofst, const MPdtExpandOptions &opts)
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const std::vector< typename Arc::Label > &assignments, MutableFst< Arc > *ofst, bool connect=true, bool keep_parentheses=false)
 
template<typename Label >
bool ReadLabelTriples (const std::string &source, std::vector< std::pair< Label, Label >> *pairs, std::vector< Label > *assignments, bool allow_negative=false)
 
template<typename Label >
bool WriteLabelTriples (const std::string &source, const std::vector< std::pair< Label, Label >> &pairs, const std::vector< Label > &assignments)
 
template<class Arc , class RevArc >
void Reverse (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, std::vector< typename Arc::Label > *assignments, MutableFst< RevArc > *ofst)
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const PdtComposeOptions &opts=PdtComposeOptions())
 
template<class Arc >
void Compose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, const PdtComposeOptions &opts=PdtComposeOptions())
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, const PdtExpandOptions< Arc > &opts)
 
template<class Arc >
void Expand (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, bool connect=true, bool keep_parentheses=false)
 
template<class Arc >
void PrintPdtInfo (const PdtInfo< Arc > &info)
 
template<typename S , typename K >
bool operator== (const PdtStateTuple< S, K > &x, const PdtStateTuple< S, K > &y)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, std::vector< std::pair< typename Arc::Label, typename Arc::Label >> *parens, const PdtReplaceOptions< Arc > &opts)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, std::vector< std::pair< typename Arc::Label, typename Arc::Label >> *parens, typename Arc::Label root)
 
template<class Arc , class RevArc >
void Reverse (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< RevArc > *ofst)
 
template<class Arc , class Queue >
void ShortestPath (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst, const PdtShortestPathOptions< Arc, Queue > &opts)
 
template<class Arc >
void ShortestPath (const Fst< Arc > &ifst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &parens, MutableFst< Arc > *ofst)
 
template<class T >
constexpr bool operator== (const FloatWeightTpl< T > &w1, const FloatWeightTpl< T > &w2)
 
constexpr bool operator== (const FloatWeightTpl< float > &w1, const FloatWeightTpl< float > &w2)
 
constexpr bool operator== (const FloatWeightTpl< double > &w1, const FloatWeightTpl< double > &w2)
 
template<class T >
constexpr bool operator!= (const FloatWeightTpl< T > &w1, const FloatWeightTpl< T > &w2)
 
constexpr bool operator!= (const FloatWeightTpl< float > &w1, const FloatWeightTpl< float > &w2)
 
constexpr bool operator!= (const FloatWeightTpl< double > &w1, const FloatWeightTpl< double > &w2)
 
template<class T >
constexpr bool FloatApproxEqual (T w1, T w2, float delta=kDelta)
 
template<class T >
constexpr bool ApproxEqual (const FloatWeightTpl< T > &w1, const FloatWeightTpl< T > &w2, float delta=kDelta)
 
template<class T >
std::ostream & operator<< (std::ostream &strm, const FloatWeightTpl< T > &w)
 
template<class T >
std::istream & operator>> (std::istream &strm, FloatWeightTpl< T > &w)
 
template<class T >
constexpr TropicalWeightTpl< T > Plus (const TropicalWeightTpl< T > &w1, const TropicalWeightTpl< T > &w2)
 
constexpr TropicalWeightTpl< float > Plus (const TropicalWeightTpl< float > &w1, const TropicalWeightTpl< float > &w2)
 
constexpr TropicalWeightTpl< double > Plus (const TropicalWeightTpl< double > &w1, const TropicalWeightTpl< double > &w2)
 
template<class T >
constexpr TropicalWeightTpl< T > Times (const TropicalWeightTpl< T > &w1, const TropicalWeightTpl< T > &w2)
 
constexpr TropicalWeightTpl< float > Times (const TropicalWeightTpl< float > &w1, const TropicalWeightTpl< float > &w2)
 
constexpr TropicalWeightTpl< double > Times (const TropicalWeightTpl< double > &w1, const TropicalWeightTpl< double > &w2)
 
template<class T >
constexpr TropicalWeightTpl< T > Divide (const TropicalWeightTpl< T > &w1, const TropicalWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr TropicalWeightTpl< float > Divide (const TropicalWeightTpl< float > &w1, const TropicalWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr TropicalWeightTpl< double > Divide (const TropicalWeightTpl< double > &w1, const TropicalWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T , class V , bool Enable = !std::is_same<V, size_t>::value, typename std::enable_if< Enable >::type * = nullptr>
constexpr TropicalWeightTpl< T > Power (const TropicalWeightTpl< T > &w, V n)
 
template<>
constexpr TropicalWeightTpl< float > Power< TropicalWeightTpl< float > > (const TropicalWeightTpl< float > &weight, size_t n)
 
template<>
constexpr TropicalWeightTpl< double > Power< TropicalWeightTpl< double > > (const TropicalWeightTpl< double > &weight, size_t n)
 
template<class T >
LogWeightTpl< T > Plus (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
LogWeightTpl< float > Plus (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2)
 
LogWeightTpl< double > Plus (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2)
 
template<class T >
LogWeightTpl< T > Minus (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
LogWeightTpl< float > Minus (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2)
 
LogWeightTpl< double > Minus (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2)
 
template<class T >
constexpr LogWeightTpl< T > Times (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
constexpr LogWeightTpl< float > Times (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2)
 
constexpr LogWeightTpl< double > Times (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2)
 
template<class T >
constexpr LogWeightTpl< T > Divide (const LogWeightTpl< T > &w1, const LogWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr LogWeightTpl< float > Divide (const LogWeightTpl< float > &w1, const LogWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr LogWeightTpl< double > Divide (const LogWeightTpl< double > &w1, const LogWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T , class V , bool Enable = !std::is_same<V, size_t>::value, typename std::enable_if< Enable >::type * = nullptr>
constexpr LogWeightTpl< T > Power (const LogWeightTpl< T > &w, V n)
 
template<>
constexpr LogWeightTpl< float > Power< LogWeightTpl< float > > (const LogWeightTpl< float > &weight, size_t n)
 
template<>
constexpr LogWeightTpl< double > Power< LogWeightTpl< double > > (const LogWeightTpl< double > &weight, size_t n)
 
template<class T >
RealWeightTpl< T > Plus (const RealWeightTpl< T > &w1, const RealWeightTpl< T > &w2)
 
RealWeightTpl< float > Plus (const RealWeightTpl< float > &w1, const RealWeightTpl< float > &w2)
 
RealWeightTpl< double > Plus (const RealWeightTpl< double > &w1, const RealWeightTpl< double > &w2)
 
template<class T >
RealWeightTpl< T > Minus (const RealWeightTpl< T > &w1, const RealWeightTpl< T > &w2)
 
RealWeightTpl< float > Minus (const RealWeightTpl< float > &w1, const RealWeightTpl< float > &w2)
 
RealWeightTpl< double > Minus (const RealWeightTpl< double > &w1, const RealWeightTpl< double > &w2)
 
template<class T >
constexpr RealWeightTpl< T > Times (const RealWeightTpl< T > &w1, const RealWeightTpl< T > &w2)
 
constexpr RealWeightTpl< float > Times (const RealWeightTpl< float > &w1, const RealWeightTpl< float > &w2)
 
constexpr RealWeightTpl< double > Times (const RealWeightTpl< double > &w1, const RealWeightTpl< double > &w2)
 
template<class T >
constexpr RealWeightTpl< T > Divide (const RealWeightTpl< T > &w1, const RealWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr RealWeightTpl< float > Divide (const RealWeightTpl< float > &w1, const RealWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr RealWeightTpl< double > Divide (const RealWeightTpl< double > &w1, const RealWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T , class V , bool Enable = !std::is_same<V, size_t>::value, typename std::enable_if< Enable >::type * = nullptr>
constexpr RealWeightTpl< T > Power (const RealWeightTpl< T > &w, V n)
 
template<>
constexpr RealWeightTpl< float > Power< RealWeightTpl< float > > (const RealWeightTpl< float > &weight, size_t n)
 
template<>
constexpr RealWeightTpl< double > Power< RealWeightTpl< double > > (const RealWeightTpl< double > &weight, size_t n)
 
template<class T >
constexpr MinMaxWeightTpl< T > Plus (const MinMaxWeightTpl< T > &w1, const MinMaxWeightTpl< T > &w2)
 
constexpr MinMaxWeightTpl< float > Plus (const MinMaxWeightTpl< float > &w1, const MinMaxWeightTpl< float > &w2)
 
constexpr MinMaxWeightTpl< double > Plus (const MinMaxWeightTpl< double > &w1, const MinMaxWeightTpl< double > &w2)
 
template<class T >
constexpr MinMaxWeightTpl< T > Times (const MinMaxWeightTpl< T > &w1, const MinMaxWeightTpl< T > &w2)
 
constexpr MinMaxWeightTpl< float > Times (const MinMaxWeightTpl< float > &w1, const MinMaxWeightTpl< float > &w2)
 
constexpr MinMaxWeightTpl< double > Times (const MinMaxWeightTpl< double > &w1, const MinMaxWeightTpl< double > &w2)
 
template<class T >
constexpr MinMaxWeightTpl< T > Divide (const MinMaxWeightTpl< T > &w1, const MinMaxWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr MinMaxWeightTpl< float > Divide (const MinMaxWeightTpl< float > &w1, const MinMaxWeightTpl< float > &w2, DivideType typ=DIVIDE_ANY)
 
constexpr MinMaxWeightTpl< double > Divide (const MinMaxWeightTpl< double > &w1, const MinMaxWeightTpl< double > &w2, DivideType typ=DIVIDE_ANY)
 
template<class FST >
void Destroy (ArcIterator< FST > *aiter, MemoryPool< ArcIterator< FST >> *pool)
 
template<class IFST , class OFST >
void Cast (const IFST &ifst, OFST *ofst)
 
template<class Arc >
std::string FstToString (const Fst< Arc > &fst, const FstWriteOptions &options=FstWriteOptions("FstToString"))
 
template<class Arc >
void FstToString (const Fst< Arc > &fst, std::string *result)
 
template<class Arc >
void FstToString (const Fst< Arc > &fst, std::string *result, const FstWriteOptions &options)
 
template<class Arc >
Fst< Arc > * StringToFst (const std::string &s)
 
template<class Label >
bool ByteStringToLabels (const std::string &str, std::vector< Label > *labels)
 
template<class Label >
bool UTF8StringToLabels (const std::string &str, std::vector< Label > *labels)
 
template<class Label >
bool LabelsToByteString (const std::vector< Label > &labels, std::string *str)
 
template<class Label >
bool LabelsToUTF8String (const std::vector< Label > &labels, std::string *str)
 
template<class Arc >
void Intersect (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst, const IntersectOptions &opts=IntersectOptions())
 
template<typename T , class Store >
std::ostream & operator<< (std::ostream &strm, const IntervalSet< T, Store > &s)
 
template<class Arc >
void Invert (const Fst< Arc > &ifst, MutableFst< Arc > *ofst)
 
template<class Arc >
void Invert (MutableFst< Arc > *fst)
 
template<class Arc >
bool Isomorphic (const Fst< Arc > &fst1, const Fst< Arc > &fst2, float delta=kDelta)
 
template<typename Label , typename StateId >
bool StateSort (std::vector< IntervalSet< Label >> *interval_sets, const std::vector< StateId > &order)
 
template<typename Label , typename StateId >
bool StateSort (LabelReachableData< Label > *data, const std::vector< StateId > &order)
 
template<class W1 , class W2 >
LexicographicWeight< W1, W2 > Plus (const LexicographicWeight< W1, W2 > &w, const LexicographicWeight< W1, W2 > &v)
 
template<class W1 , class W2 >
LexicographicWeight< W1, W2 > Times (const LexicographicWeight< W1, W2 > &w, const LexicographicWeight< W1, W2 > &v)
 
template<class W1 , class W2 >
LexicographicWeight< W1, W2 > Divide (const LexicographicWeight< W1, W2 > &w, const LexicographicWeight< W1, W2 > &v, DivideType typ=DIVIDE_ANY)
 
template<class Matcher1 , class Matcher2 >
MatchType LookAheadMatchType (const Matcher1 &m1, const Matcher2 &m2)
 
template<class Arc >
MatchType LookAheadMatchType (const Fst< Arc > &fst1, const Fst< Arc > &fst2)
 
template<class Reachable , class FST , class Data >
void RelabelForReachable (FST *fst, const Data &data, const std::string &save_relabel_ipairs, const std::string &save_relabel_opairs)
 
template<class A , class C >
void Map (MutableFst< A > *fst, C *mapper)
 
template<class A , class C >
void Map (MutableFst< A > *fst, C mapper)
 
template<class A , class B , class C >
void Map (const Fst< A > &ifst, MutableFst< B > *ofst, C *mapper)
 
template<class A , class B , class C >
void Map (const Fst< A > &ifst, MutableFst< B > *ofst, C mapper)
 
template<typename T , typename U >
bool operator== (const BlockAllocator< T > &alloc1, const BlockAllocator< U > &alloc2)
 
template<typename T , typename U >
bool operator!= (const BlockAllocator< T > &alloc1, const BlockAllocator< U > &alloc2)
 
template<typename T , typename U >
bool operator== (const PoolAllocator< T > &alloc1, const PoolAllocator< U > &alloc2)
 
template<typename T , typename U >
bool operator!= (const PoolAllocator< T > &alloc1, const PoolAllocator< U > &alloc2)
 
template<class Arc >
void Minimize (MutableFst< Arc > *fst, MutableFst< Arc > *sfst=nullptr, float delta=kShortestDelta, bool allow_nondet=false)
 
template<class W1 , class W2 >
bool operator== (const PairWeight< W1, W2 > &w1, const PairWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
bool operator!= (const PairWeight< W1, W2 > &w1, const PairWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
bool ApproxEqual (const PairWeight< W1, W2 > &w1, const PairWeight< W1, W2 > &w2, float delta=kDelta)
 
template<class W1 , class W2 >
std::ostream & operator<< (std::ostream &strm, const PairWeight< W1, W2 > &weight)
 
template<class W1 , class W2 >
std::istream & operator>> (std::istream &strm, PairWeight< W1, W2 > &weight)
 
template<class W , size_t n>
PowerWeight< W, n > Plus (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2)
 
template<class W , size_t n>
PowerWeight< W, n > Times (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2)
 
template<class W , size_t n>
PowerWeight< W, n > Divide (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2, DivideType type=DIVIDE_ANY)
 
template<class W , size_t n>
PowerWeight< W, n > Times (const W &scalar, const PowerWeight< W, n > &weight)
 
template<class W , size_t n>
PowerWeight< W, n > Times (const PowerWeight< W, n > &weight, const W &scalar)
 
template<class W , size_t n>
DotProduct (const PowerWeight< W, n > &w1, const PowerWeight< W, n > &w2)
 
template<class W1 , class W2 >
ProductWeight< W1, W2 > Plus (const ProductWeight< W1, W2 > &w1, const ProductWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
ProductWeight< W1, W2 > Times (const ProductWeight< W1, W2 > &w1, const ProductWeight< W1, W2 > &w2)
 
template<class W1 , class W2 >
ProductWeight< W1, W2 > Divide (const ProductWeight< W1, W2 > &w1, const ProductWeight< W1, W2 > &w2, DivideType typ=DIVIDE_ANY)
 
template<class Arc >
void Project (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, ProjectType project_type)
 
template<class Arc >
void Project (MutableFst< Arc > *fst, ProjectType project_type)
 
uint64 SetStartProperties (uint64 inprops)
 
template<typename Weight >
uint64 SetFinalProperties (uint64 inprops, const Weight &old_weight, const Weight &new_weight)
 
uint64 AddStateProperties (uint64 inprops)
 
template<typename A >
uint64 AddArcProperties (uint64 inprops, typename A::StateId s, const A &arc, const A *prev_arc)
 
uint64 DeleteStatesProperties (uint64 inprops)
 
uint64 DeleteAllStatesProperties (uint64 inprops, uint64 staticProps)
 
uint64 DeleteArcsProperties (uint64 inprops)
 
uint64 ClosureProperties (uint64 inprops, bool star, bool delayed=false)
 
uint64 ComplementProperties (uint64 inprops)
 
uint64 ComposeProperties (uint64 inprops1, uint64 inprops2)
 
uint64 ConcatProperties (uint64 inprops1, uint64 inprops2, bool delayed=false)
 
uint64 DeterminizeProperties (uint64 inprops, bool has_subsequential_label, bool distinct_psubsequential_labels)
 
uint64 FactorWeightProperties (uint64 inprops)
 
uint64 InvertProperties (uint64 inprops)
 
uint64 ProjectProperties (uint64 inprops, bool project_input)
 
uint64 RandGenProperties (uint64 inprops, bool weighted)
 
uint64 RelabelProperties (uint64 inprops)
 
uint64 ReplaceProperties (const std::vector< uint64 > &inprops, size_t root, bool epsilon_on_call, bool epsilon_on_return, bool out_epsilon_on_call, bool out_epsilon_on_return, bool replace_transducer, bool no_empty_fst, bool all_ilabel_sorted, bool all_olabel_sorted, bool all_negative_or_dense)
 
uint64 ReverseProperties (uint64 inprops, bool has_superinitial)
 
uint64 ReweightProperties (uint64 inprops, bool added_start_epsilon)
 
uint64 RmEpsilonProperties (uint64 inprops, bool delayed=false)
 
uint64 ShortestPathProperties (uint64 props, bool tree=false)
 
uint64 SynchronizeProperties (uint64 inprops)
 
uint64 UnionProperties (uint64 inprops1, uint64 inprops2, bool delayed=false)
 
template<typename Arc >
uint64 AddArcProperties (uint64 inprops, typename Arc::StateId s, const Arc &arc, const Arc *prev_arc)
 
template<class Arc , class ArcFilter >
void Prune (MutableFst< Arc > *fst, const PruneOptions< Arc, ArcFilter > &opts=PruneOptions< Arc, ArcFilter >())
 
template<class Arc >
void Prune (MutableFst< Arc > *fst, typename Arc::Weight weight_threshold, typename Arc::StateId state_threshold=kNoStateId, float delta=kDelta)
 
template<class Arc , class ArcFilter >
void Prune (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, const PruneOptions< Arc, ArcFilter > &opts=PruneOptions< Arc, ArcFilter >())
 
template<class Arc >
void Prune (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, typename Arc::Weight weight_threshold, typename Arc::StateId state_threshold=kNoStateId, float delta=kDelta)
 
template<class Arc >
Arc::Weight ComputeTotalWeight (const Fst< Arc > &fst, const std::vector< typename Arc::Weight > &distance, bool reverse)
 
template<class Arc >
void RemoveWeight (MutableFst< Arc > *fst, const typename Arc::Weight &weight, bool at_final)
 
template<class Arc >
void Push (MutableFst< Arc > *fst, ReweightType type=REWEIGHT_TO_INITIAL, float delta=kShortestDelta, bool remove_total_weight=false)
 
template<class Arc , ReweightType rtype>
void Push (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, uint8 ptype, float delta=kShortestDelta)
 
template<class Arc , class ArcSelector >
bool RandEquivalent (const Fst< Arc > &fst1, const Fst< Arc > &fst2, int32 npath, const RandGenOptions< ArcSelector > &opts, float delta=kDelta, uint64 seed=std::random_device()(), bool *error=nullptr)
 
template<class Arc >
bool RandEquivalent (const Fst< Arc > &fst1, const Fst< Arc > &fst2, int32 npath, float delta=kDelta, uint64 seed=std::random_device()(), int32 max_length=std::numeric_limits< int32 >::max(), bool *error=nullptr)
 
template<class Result , class RNG >
void OneMultinomialSample (const std::vector< double > &probs, size_t num_to_sample, Result *result, RNG *rng)
 
template<class FromArc , class ToArc , class Selector >
void RandGen (const Fst< FromArc > &ifst, MutableFst< ToArc > *ofst, const RandGenOptions< Selector > &opts)
 
template<class FromArc , class ToArc >
void RandGen (const Fst< FromArc > &ifst, MutableFst< ToArc > *ofst, uint64 seed=std::random_device()())
 
template<class Arc >
void Union (RationalFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
Fst< Arc > * Convert (const Fst< Arc > &fst, const std::string &fst_type)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &ipairs, const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &opairs)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const SymbolTable *old_isymbols, const SymbolTable *new_isymbols, const std::string &unknown_isymbol, bool attach_new_isymbols, const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, const std::string &unknown_osymbol, bool attach_new_osymbols)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const SymbolTable *old_isymbols, const SymbolTable *new_isymbols, bool attach_new_isymbols, const SymbolTable *old_osymbols, const SymbolTable *new_osymbols, bool attach_new_osymbols)
 
template<class Arc >
void Relabel (MutableFst< Arc > *fst, const SymbolTable *new_isymbols, const SymbolTable *new_osymbols)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &, MutableFst< Arc > *, const ReplaceUtilOptions &)
 
template<class StateId , class PrefixId >
bool operator== (const ReplaceStateTuple< StateId, PrefixId > &x, const ReplaceStateTuple< StateId, PrefixId > &y)
 
template<class Label , class StateId >
bool operator== (const ReplaceStackPrefix< Label, StateId > &x, const ReplaceStackPrefix< Label, StateId > &y)
 
bool EpsilonOnInput (ReplaceLabelType label_type)
 
bool EpsilonOnOutput (ReplaceLabelType label_type)
 
template<class Label >
bool ReplaceTransducer (ReplaceLabelType call_label_type, ReplaceLabelType return_label_type, Label call_output_label)
 
template<class Arc >
uint64 ReplaceFstProperties (typename Arc::Label root_label, const FstList< Arc > &fst_list, ReplaceLabelType call_label_type, ReplaceLabelType return_label_type, typename Arc::Label call_output_label, bool *sorted_and_non_empty)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, ReplaceFstOptions< Arc > opts=ReplaceFstOptions< Arc >())
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, typename Arc::Label root, bool epsilon_on_replace)
 
template<class Arc >
void Replace (const std::vector< std::pair< typename Arc::Label, const Fst< Arc > * >> &ifst_array, MutableFst< Arc > *ofst, typename Arc::Label root)
 
template<class FromArc , class ToArc >
void Reverse (const Fst< FromArc > &ifst, MutableFst< ToArc > *ofst, bool require_superinitial=true)
 
template<class Arc >
void Reweight (MutableFst< Arc > *fst, const std::vector< typename Arc::Weight > &potential, ReweightType type)
 
template<class Arc , class Queue >
void RmEpsilon (MutableFst< Arc > *fst, std::vector< typename Arc::Weight > *distance, const RmEpsilonOptions< Arc, Queue > &opts)
 
template<class Arc >
void RmEpsilon (MutableFst< Arc > *fst, bool connect=true, typename Arc::Weight weight_threshold=Arc::Weight::Zero(), typename Arc::StateId state_threshold=kNoStateId, float delta=kShortestDelta)
 
template<class Arc >
void RmFinalEpsilon (MutableFst< Arc > *fst)
 
void PrintProperties (std::ostream &ostrm, uint64 properties)
 
void PrintHeader (std::ostream &ostrm, const FstHeader &header)
 
template<typename Label , SetType S>
bool operator== (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label >
bool operator== (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2)
 
template<typename Label , SetType S>
bool operator!= (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
bool ApproxEqual (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2, float delta=kDelta)
 
template<typename Label , SetType S>
std::ostream & operator<< (std::ostream &strm, const SetWeight< Label, S > &weight)
 
template<typename Label , SetType S>
std::istream & operator>> (std::istream &strm, SetWeight< Label, S > &weight)
 
template<typename Label , SetType S>
SetWeight< Label, S > Union (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Intersect (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Difference (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Plus (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label >
SetWeight< Label, SET_UNION_INTERSECTPlus (const SetWeight< Label, SET_UNION_INTERSECT > &w1, const SetWeight< Label, SET_UNION_INTERSECT > &w2)
 
template<typename Label >
SetWeight< Label, SET_INTERSECT_UNION_RESTRICTPlus (const SetWeight< Label, SET_INTERSECT_UNION_RESTRICT > &w1, const SetWeight< Label, SET_INTERSECT_UNION_RESTRICT > &w2)
 
template<typename Label >
SetWeight< Label, SET_BOOLEANPlus (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Times (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2)
 
template<typename Label >
SetWeight< Label, SET_UNION_INTERSECTTimes (const SetWeight< Label, SET_UNION_INTERSECT > &w1, const SetWeight< Label, SET_UNION_INTERSECT > &w2)
 
template<typename Label >
SetWeight< Label, SET_BOOLEANTimes (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2)
 
template<typename Label , SetType S>
SetWeight< Label, S > Divide (const SetWeight< Label, S > &w1, const SetWeight< Label, S > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<typename Label >
SetWeight< Label, SET_UNION_INTERSECTDivide (const SetWeight< Label, SET_UNION_INTERSECT > &w1, const SetWeight< Label, SET_UNION_INTERSECT > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<typename Label >
SetWeight< Label, SET_BOOLEANDivide (const SetWeight< Label, SET_BOOLEAN > &w1, const SetWeight< Label, SET_BOOLEAN > &w2, DivideType divide_type=DIVIDE_ANY)
 
template<class Arc , class Queue , class ArcFilter >
void ShortestDistance (const Fst< Arc > &fst, std::vector< typename Arc::Weight > *distance, const ShortestDistanceOptions< Arc, Queue, ArcFilter > &opts)
 
template<class Arc >
void ShortestDistance (const Fst< Arc > &fst, std::vector< typename Arc::Weight > *distance, bool reverse=false, float delta=kShortestDelta)
 
template<class Arc >
Arc::Weight ShortestDistance (const Fst< Arc > &fst, float delta=kShortestDelta)
 
template<class Arc , class Queue , class ArcFilter >
void ShortestPath (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, std::vector< typename Arc::Weight > *distance, const ShortestPathOptions< Arc, Queue, ArcFilter > &opts)
 
template<class Arc >
void ShortestPath (const Fst< Arc > &ifst, MutableFst< Arc > *ofst, int32 nshortest=1, bool unique=false, bool first_path=false, typename Arc::Weight weight_threshold=Arc::Weight::Zero(), typename Arc::StateId state_threshold=kNoStateId, float delta=kShortestDelta)
 
template<class T >
SignedLogWeightTpl< T > Plus (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Minus (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Times (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Divide (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T >
bool ApproxEqual (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2, float delta=kDelta)
 
template<class T >
bool operator== (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
bool operator!= (const SignedLogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Plus (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Plus (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Minus (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Minus (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Times (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Times (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
template<class T >
SignedLogWeightTpl< T > Divide (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T >
SignedLogWeightTpl< T > Divide (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2, DivideType typ=DIVIDE_ANY)
 
template<class T >
bool ApproxEqual (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2, float delta=kDelta)
 
template<class T >
bool ApproxEqual (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2, float delta=kDelta)
 
template<class T >
bool operator== (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
bool operator== (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
template<class T >
bool operator!= (const LogWeightTpl< T > &w1, const SignedLogWeightTpl< T > &w2)
 
template<class T >
bool operator!= (const SignedLogWeightTpl< T > &w1, const LogWeightTpl< T > &w2)
 
template<class W1 , class W2 >
bool SignedLogConvertCheck (W1 weight)
 
template<class W , class K , class M >
SparsePowerWeight< W, K > SparsePowerWeightMap (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2, const M &operator_mapper)
 
template<class W , class K >
SparsePowerWeight< W, K > Plus (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Minus (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Times (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Divide (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2, DivideType type=DIVIDE_ANY)
 
template<class W , class K >
const W & DotProduct (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
bool ApproxEqual (const SparsePowerWeight< W, K > &w1, const SparsePowerWeight< W, K > &w2, float delta=kDelta)
 
template<class W , class K >
SparsePowerWeight< W, K > Times (const W &k, const SparsePowerWeight< W, K > &w2)
 
template<class W , class K >
SparsePowerWeight< W, K > Times (const SparsePowerWeight< W, K > &w1, const W &k)
 
template<class W , class K >
SparsePowerWeight< W, K > Divide (const SparsePowerWeight< W, K > &w1, const W &k, DivideType divide_type=DIVIDE_ANY)
 
template<class W , class K , class M >
void SparseTupleWeightMap (SparseTupleWeight< W, K > *result, const SparseTupleWeight< W, K > &w1, const SparseTupleWeight< W, K > &w2, const M &operator_mapper)
 
template<class W , class K >
bool operator== (const SparseTupleWeight< W, K > &w1, const SparseTupleWeight< W, K > &w2)
 
template<class W , class K >
bool operator!= (const SparseTupleWeight< W, K > &w1, const SparseTupleWeight< W, K > &w2)
 
template<class W , class K >
std::ostream & operator<< (std::ostream &strm, const SparseTupleWeight< W, K > &weight)
 
template<class W , class K >
std::istream & operator>> (std::istream &strm, SparseTupleWeight< W, K > &weight)
 
template<class A , class C >
void StateMap (MutableFst< A > *fst, C *mapper)
 
template<class A , class C >
void StateMap (MutableFst< A > *fst, C mapper)
 
template<class A , class B , class C >
void StateMap (const Fst< A > &ifst, MutableFst< B > *ofst, C *mapper)
 
template<class A , class B , class C >
void StateMap (const Fst< A > &ifst, MutableFst< B > *ofst, C mapper)
 
template<class Arc >
void StateSort (MutableFst< Arc > *fst, const std::vector< typename Arc::StateId > &order)
 
constexpr StringType ReverseStringType (StringType s)
 
template<typename Label , StringType S>
bool operator== (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
bool operator!= (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
bool ApproxEqual (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2, float delta=kDelta)
 
template<typename Label , StringType S>
std::ostream & operator<< (std::ostream &strm, const StringWeight< Label, S > &weight)
 
template<typename Label , StringType S>
std::istream & operator>> (std::istream &strm, StringWeight< Label, S > &weight)
 
template<typename Label , StringType S>
StringWeight< Label, S > Plus (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label >
StringWeight< Label, STRING_LEFTPlus (const StringWeight< Label, STRING_LEFT > &w1, const StringWeight< Label, STRING_LEFT > &w2)
 
template<typename Label >
StringWeight< Label, STRING_RIGHTPlus (const StringWeight< Label, STRING_RIGHT > &w1, const StringWeight< Label, STRING_RIGHT > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > Times (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > DivideLeft (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > DivideRight (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2)
 
template<typename Label , StringType S>
StringWeight< Label, S > Divide (const StringWeight< Label, S > &w1, const StringWeight< Label, S > &w2, DivideType divide_type)
 
template<typename Label >
StringWeight< Label, STRING_LEFTDivide (const StringWeight< Label, STRING_LEFT > &w1, const StringWeight< Label, STRING_LEFT > &w2, DivideType divide_type)
 
template<typename Label >
StringWeight< Label, STRING_RIGHTDivide (const StringWeight< Label, STRING_RIGHT > &w1, const StringWeight< Label, STRING_RIGHT > &w2, DivideType divide_type)
 
constexpr StringType GallicStringType (GallicType g)
 
constexpr GallicType ReverseGallicType (GallicType g)
 
template<class Label , class W , GallicType G>
GallicWeight< Label, W, G > Plus (const GallicWeight< Label, W, G > &w, const GallicWeight< Label, W, G > &v)
 
template<class Label , class W >
GallicWeight< Label, W, GALLIC_MINPlus (const GallicWeight< Label, W, GALLIC_MIN > &w1, const GallicWeight< Label, W, GALLIC_MIN > &w2)
 
template<class Label , class W , GallicType G>
GallicWeight< Label, W, G > Times (const GallicWeight< Label, W, G > &w, const GallicWeight< Label, W, G > &v)
 
template<class Label , class W , GallicType G>
GallicWeight< Label, W, G > Divide (const GallicWeight< Label, W, G > &w, const GallicWeight< Label, W, G > &v, DivideType divide_type=DIVIDE_ANY)
 
template<class Label , class W >
GallicWeight< Label, W, GALLICPlus (const GallicWeight< Label, W, GALLIC > &w1, const GallicWeight< Label, W, GALLIC > &w2)
 
template<class Label , class W >
GallicWeight< Label, W, GALLICTimes (const GallicWeight< Label, W, GALLIC > &w1, const GallicWeight< Label, W, GALLIC > &w2)
 
template<class Label , class W >
GallicWeight< Label, W, GALLICDivide (const GallicWeight< Label, W, GALLIC > &w1, const GallicWeight< Label, W, GALLIC > &w2, DivideType divide_type=DIVIDE_ANY)
 
std::ostream & operator<< (std::ostream &strm, const TokenType &token_type)
 
template<class Arc >
bool StringFstToOutputLabels (const Fst< Arc > &fst, std::vector< typename Arc::Label > *labels)
 
template<class Label >
bool LabelsToString (const std::vector< Label > &labels, std::string *str, TokenType ttype=TokenType::BYTE, const SymbolTable *syms=nullptr, const std::string &sep=FST_FLAGS_fst_field_separator, bool omit_epsilon=true)
 
template<class Arc >
SymbolTablePruneSymbolTable (const Fst< Arc > &fst, const SymbolTable &syms, bool input)
 
SymbolTableCompactSymbolTable (const SymbolTable &syms)
 
SymbolTableMergeSymbolTable (const SymbolTable &left, const SymbolTable &right, bool *right_relabel_output=nullptr)
 
SymbolTableFstReadSymbols (const std::string &source, bool input)
 
bool AddAuxiliarySymbols (const std::string &prefix, int64 start_label, int64 nlabels, SymbolTable *syms)
 
class OPENFST_DEPRECATED ("Use SymbolTable::iterator, a C++ compliant iterator, instead") SymbolTableIterator
 
template<class Label >
SymbolTableRelabelSymbolTable (const SymbolTable *table, const std::vector< std::pair< Label, Label >> &pairs)
 
bool CompatSymbols (const SymbolTable *syms1, const SymbolTable *syms2, bool warning=true)
 
void SymbolTableToString (const SymbolTable *table, std::string *result)
 
SymbolTableStringToSymbolTable (const std::string &str)
 
template<class Arc >
void Synchronize (const Fst< Arc > &ifst, MutableFst< Arc > *ofst)
 
template<class Arc >
void LookAheadCompose (const Fst< Arc > &ifst1, const Fst< Arc > &ifst2, MutableFst< Arc > *ofst)
 
void LookAheadCompose (const Fst< StdArc > &ifst1, const Fst< StdArc > &ifst2, MutableFst< StdArc > *ofst)
 
template<class Arc , class Generate >
void RandFst (const int num_random_states, const int num_random_arcs, const int num_random_labels, const float acyclic_prob, Generate generate, uint64 seed, MutableFst< Arc > *fst)
 
template<class Arc >
bool TopSort (MutableFst< Arc > *fst)
 
template<class W , size_t n>
bool operator== (const TupleWeight< W, n > &w1, const TupleWeight< W, n > &w2)
 
template<class W , size_t n>
bool operator!= (const TupleWeight< W, n > &w1, const TupleWeight< W, n > &w2)
 
template<class W , size_t n>
bool ApproxEqual (const TupleWeight< W, n > &w1, const TupleWeight< W, n > &w2, float delta=kDelta)
 
template<class W , size_t n>
std::ostream & operator<< (std::ostream &strm, const TupleWeight< W, n > &w)
 
template<class W , size_t n>
std::istream & operator>> (std::istream &strm, TupleWeight< W, n > &w)
 
template<class W , class O >
bool operator== (const UnionWeight< W, O > &, const UnionWeight< W, O > &)
 
template<class W , class O >
bool operator!= (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2)
 
template<class W , class O >
bool ApproxEqual (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2, float delta=kDelta)
 
template<class W , class O >
std::ostream & operator<< (std::ostream &ostrm, const UnionWeight< W, O > &weight)
 
template<class W , class O >
std::istream & operator>> (std::istream &istrm, UnionWeight< W, O > &weight)
 
template<class W , class O >
UnionWeight< W, O > Plus (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2)
 
template<class W , class O >
UnionWeight< W, O > Times (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2)
 
template<class W , class O >
UnionWeight< W, O > Divide (const UnionWeight< W, O > &w1, const UnionWeight< W, O > &w2, DivideType typ)
 
template<class Arc >
void Union (MutableFst< Arc > *fst1, const Fst< Arc > &fst2)
 
template<class Arc >
void Union (MutableFst< Arc > *fst1, const std::vector< const Fst< Arc > * > &fsts2)
 
template<class T , typename std::enable_if< std::is_class< T >::value, T >::type * = nullptr>
std::istream & ReadType (std::istream &strm, T *t)
 
std::istream & ReadType (std::istream &strm, std::string *s)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::vector< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::list< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::set< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::map< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::unordered_map< T... > *c)
 
template<class... T>
std::istream & ReadType (std::istream &strm, std::unordered_set< T... > *c)
 
template<typename S , typename T >
std::istream & ReadType (std::istream &strm, std::pair< S, T > *p)
 
template<typename S , typename T >
std::istream & ReadType (std::istream &strm, std::pair< const S, T > *p)
 
template<class T , size_t N>
std::istream & ReadType (std::istream &strm, std::array< T, N > *c)
 
template<class T , typename std::enable_if< std::is_class< T >::value, T >::type * = nullptr>
std::ostream & WriteType (std::ostream &strm, const T t)
 
std::ostream & WriteType (std::ostream &strm, const std::string &s)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::vector< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::list< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::set< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::map< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::unordered_map< T... > &c)
 
template<typename... T>
std::ostream & WriteType (std::ostream &strm, const std::unordered_set< T... > &c)
 
template<typename S , typename T >
std::ostream & WriteType (std::ostream &strm, const std::pair< S, T > &p)
 
template<class T , size_t N>
std::ostream & WriteType (std::ostream &strm, const std::array< T, N > &c)
 
std::optional< int64ParseInt64 (std::string_view s)
 
int64 StrToInt64 (std::string_view s, std::string_view source, size_t nline, bool allow_negative, bool *error=nullptr)
 
template<typename Weight >
Weight StrToWeight (std::string_view s)
 
template<typename Weight >
void WeightToStr (Weight w, std::string *s)
 
std::vector< std::string_view > SplitString (std::string_view line, std::string_view delim, bool omit_empty_strings)
 
template<typename I >
bool ReadIntPairs (const std::string &source, std::vector< std::pair< I, I >> *pairs, bool allow_negative=false)
 
template<typename I >
bool WriteIntPairs (const std::string &source, const std::vector< std::pair< I, I >> &pairs)
 
template<typename Label >
bool ReadLabelPairs (const std::string &source, std::vector< std::pair< Label, Label >> *pairs, bool allow_negative=false)
 
template<typename Label >
bool WriteLabelPairs (const std::string &source, const std::vector< std::pair< Label, Label >> &pairs)
 
void ConvertToLegalCSymbol (std::string *s)
 
bool AlignInput (std::istream &strm, size_t align=MappedFile::kArchAlignment)
 
bool AlignOutput (std::ostream &strm, size_t align=MappedFile::kArchAlignment)
 
template<class Arc >
bool Verify (const Fst< Arc > &fst, bool allow_negative_labels=false)
 
template<class FST , class Visitor , class Queue , class ArcFilter >
void Visit (const FST &fst, Visitor *visitor, Queue *queue, ArcFilter filter, bool access_only=false)
 
template<class Arc , class Visitor , class Queue >
void Visit (const Fst< Arc > &fst, Visitor *visitor, Queue *queue)
 
template<class Weight >
Weight Power (const Weight &weight, size_t n)
 
 REGISTER_FST (VectorFst, StdArc)
 
 REGISTER_FST (VectorFst, LogArc)
 
 REGISTER_FST (VectorFst, Log64Arc)
 
 REGISTER_FST (ConstFst, StdArc)
 
 REGISTER_FST (ConstFst, LogArc)
 
 REGISTER_FST (ConstFst, Log64Arc)
 
 REGISTER_FST (EditFst, StdArc)
 
 REGISTER_FST (EditFst, LogArc)
 
 REGISTER_FST (EditFst, Log64Arc)
 
 REGISTER_FST (CompactStringFst, StdArc)
 
 REGISTER_FST (CompactStringFst, LogArc)
 
 REGISTER_FST (CompactStringFst, Log64Arc)
 
 REGISTER_FST (CompactWeightedStringFst, StdArc)
 
 REGISTER_FST (CompactWeightedStringFst, LogArc)
 
 REGISTER_FST (CompactWeightedStringFst, Log64Arc)
 
 REGISTER_FST (CompactAcceptorFst, StdArc)
 
 REGISTER_FST (CompactAcceptorFst, LogArc)
 
 REGISTER_FST (CompactAcceptorFst, Log64Arc)
 
 REGISTER_FST (CompactUnweightedFst, StdArc)
 
 REGISTER_FST (CompactUnweightedFst, LogArc)
 
 REGISTER_FST (CompactUnweightedFst, Log64Arc)
 
 REGISTER_FST (CompactUnweightedAcceptorFst, StdArc)
 
 REGISTER_FST (CompactUnweightedAcceptorFst, LogArc)
 
 REGISTER_FST (CompactUnweightedAcceptorFst, Log64Arc)
 
int AlignBufferWithOutputStream (std::ostream &strm, std::ostringstream &buffer, size_t align)
 

Variables

const char phi_fst_type [] = "phi"
 
const char input_phi_fst_type [] = "input_phi"
 
const char output_phi_fst_type [] = "output_phi"
 
const char rho_fst_type [] = "rho"
 
const char input_rho_fst_type [] = "input_rho"
 
const char output_rho_fst_type [] = "output_rho"
 
const char sigma_fst_type [] = "sigma"
 
const char input_sigma_fst_type [] = "input_sigma"
 
const char output_sigma_fst_type [] = "output_sigma"
 
constexpr uint8 kCacheFinal = 0x01
 
constexpr uint8 kCacheArcs = 0x02
 
constexpr uint8 kCacheInit = 0x04
 
constexpr uint8 kCacheRecent = 0x08
 
constexpr uint8 kCacheFlags
 
constexpr uint8 kEqualFsts = 0x01
 
constexpr uint8 kEqualFstTypes = 0x02
 
constexpr uint8 kEqualCompatProperties = 0x04
 
constexpr uint8 kEqualCompatSymbols = 0x08
 
constexpr uint8 kEqualAll
 
const int kNoTrieNodeId = -1
 
constexpr uint32 kParenList = 0x00000001
 
constexpr uint32 kParenLoop = 0x00000002
 
constexpr uint8 kPhiFstMatchInput = 0x01
 
constexpr uint8 kPhiFstMatchOutput = 0x02
 
constexpr uint8 kRhoFstMatchInput = 0x01
 
constexpr uint8 kRhoFstMatchOutput = 0x02
 
constexpr uint8 kSigmaFstMatchInput = 0x01
 
constexpr uint8 kSigmaFstMatchOutput = 0x02
 
constexpr uint8 kFactorFinalWeights = 0x01
 
constexpr uint8 kFactorArcWeights = 0x02
 
constexpr int32 kFstMagicNumber = 2125659606
 
constexpr int kNoLabel = -1
 
constexpr int kNoStateId = -1
 
constexpr uint32 kInputLookAheadMatcher = 0x00000010
 
constexpr uint32 kOutputLookAheadMatcher = 0x00000020
 
constexpr uint32 kLookAheadWeight = 0x00000040
 
constexpr uint32 kLookAheadPrefix = 0x00000080
 
constexpr uint32 kLookAheadNonEpsilons = 0x00000100
 
constexpr uint32 kLookAheadEpsilons = 0x00000200
 
constexpr uint32 kLookAheadNonEpsilonPrefix = 0x00000400
 
constexpr uint32 kLookAheadKeepRelabelData = 0x00000800
 
constexpr uint32 kLookAheadFlags = 0x00000ff0
 
const char arc_lookahead_fst_type [] = "arc_lookahead"
 
const char ilabel_lookahead_fst_type [] = "ilabel_lookahead"
 
const char olabel_lookahead_fst_type [] = "olabel_lookahead"
 
constexpr auto ilabel_lookahead_flags
 
constexpr auto olabel_lookahead_flags
 
constexpr uint32 kRequireMatch = 0x00000001
 
constexpr uint32 kMatcherFlags = kRequireMatch
 
constexpr ssize_t kRequirePriority = -1
 
const uint32 kMultiEpsList = 0x00000001
 
const uint32 kMultiEpsLoop = 0x00000002
 
constexpr int kAllocSize = 64
 
constexpr int kAllocFit = 4
 
constexpr uint64 kExpanded = 0x0000000000000001ULL
 
constexpr uint64 kMutable = 0x0000000000000002ULL
 
constexpr uint64 kError = 0x0000000000000004ULL
 
constexpr uint64 kAcceptor = 0x0000000000010000ULL
 
constexpr uint64 kNotAcceptor = 0x0000000000020000ULL
 
constexpr uint64 kIDeterministic = 0x0000000000040000ULL
 
constexpr uint64 kNonIDeterministic = 0x0000000000080000ULL
 
constexpr uint64 kODeterministic = 0x0000000000100000ULL
 
constexpr uint64 kNonODeterministic = 0x0000000000200000ULL
 
constexpr uint64 kEpsilons = 0x0000000000400000ULL
 
constexpr uint64 kNoEpsilons = 0x0000000000800000ULL
 
constexpr uint64 kIEpsilons = 0x0000000001000000ULL
 
constexpr uint64 kNoIEpsilons = 0x0000000002000000ULL
 
constexpr uint64 kOEpsilons = 0x0000000004000000ULL
 
constexpr uint64 kNoOEpsilons = 0x0000000008000000ULL
 
constexpr uint64 kILabelSorted = 0x0000000010000000ULL
 
constexpr uint64 kNotILabelSorted = 0x0000000020000000ULL
 
constexpr uint64 kOLabelSorted = 0x0000000040000000ULL
 
constexpr uint64 kNotOLabelSorted = 0x0000000080000000ULL
 
constexpr uint64 kWeighted = 0x0000000100000000ULL
 
constexpr uint64 kUnweighted = 0x0000000200000000ULL
 
constexpr uint64 kCyclic = 0x0000000400000000ULL
 
constexpr uint64 kAcyclic = 0x0000000800000000ULL
 
constexpr uint64 kInitialCyclic = 0x0000001000000000ULL
 
constexpr uint64 kInitialAcyclic = 0x0000002000000000ULL
 
constexpr uint64 kTopSorted = 0x0000004000000000ULL
 
constexpr uint64 kNotTopSorted = 0x0000008000000000ULL
 
constexpr uint64 kAccessible = 0x0000010000000000ULL
 
constexpr uint64 kNotAccessible = 0x0000020000000000ULL
 
constexpr uint64 kCoAccessible = 0x0000040000000000ULL
 
constexpr uint64 kNotCoAccessible = 0x0000080000000000ULL
 
constexpr uint64 kString = 0x0000100000000000ULL
 
constexpr uint64 kNotString = 0x0000200000000000ULL
 
constexpr uint64 kWeightedCycles = 0x0000400000000000ULL
 
constexpr uint64 kUnweightedCycles = 0x0000800000000000ULL
 
constexpr uint64 kNullProperties
 
constexpr uint64 kCompiledStringProperties
 
constexpr uint64 kCopyProperties
 
constexpr uint64 kIntrinsicProperties
 
constexpr uint64 kExtrinsicProperties = kError
 
constexpr uint64 kSetStartProperties
 
constexpr uint64 kSetFinalProperties
 
constexpr uint64 kAddStateProperties
 
constexpr uint64 kAddArcProperties
 
constexpr uint64 kSetArcProperties = kExpanded | kMutable | kError
 
constexpr uint64 kDeleteStatesProperties
 
constexpr uint64 kDeleteArcsProperties
 
constexpr uint64 kStateSortProperties
 
constexpr uint64 kArcSortProperties
 
constexpr uint64 kILabelInvariantProperties
 
constexpr uint64 kOLabelInvariantProperties
 
constexpr uint64 kWeightInvariantProperties
 
constexpr uint64 kAddSuperFinalProperties
 
constexpr uint64 kRmSuperFinalProperties
 
constexpr uint64 kBinaryProperties = 0x0000000000000007ULL
 
constexpr uint64 kTrinaryProperties = 0x0000ffffffff0000ULL
 
constexpr uint64 kPosTrinaryProperties
 
constexpr uint64 kNegTrinaryProperties
 
constexpr uint64 kFstProperties = kBinaryProperties | kTrinaryProperties
 
const char * PropertyNames []
 
constexpr uint8 kPushWeights = 0x01
 
constexpr uint8 kPushLabels = 0x02
 
constexpr uint8 kPushRemoveTotalWeight = 0x04
 
constexpr uint8 kPushRemoveCommonAffix = 0x08
 
constexpr uint8 kReplaceSCCLeftLinear = 0x01
 
constexpr uint8 kReplaceSCCRightLinear = 0x02
 
constexpr uint8 kReplaceSCCNonTrivial = 0x04
 
constexpr int kSetEmpty = 0
 
constexpr int kSetUniv = -1
 
constexpr int kSetBad = -2
 
constexpr char kSetSeparator [] = "_"
 
constexpr float kShortestDelta = 1e-6
 
constexpr int kStringInfinity = -1
 
constexpr int kStringBad = -2
 
constexpr char kStringSeparator [] = "_"
 
constexpr int64 kNoSymbol = -1
 
constexpr float kDelta = 1.0F / 1024.0F
 
constexpr uint64 kLeftSemiring = 0x0000000000000001ULL
 
constexpr uint64 kRightSemiring = 0x0000000000000002ULL
 
constexpr uint64 kSemiring = kLeftSemiring | kRightSemiring
 
constexpr uint64 kCommutative = 0x0000000000000004ULL
 
constexpr uint64 kIdempotent = 0x0000000000000008ULL
 
constexpr uint64 kPath = 0x0000000000000010ULL
 
constexpr size_t kNumRandomWeights = 5
 
constexpr int kWidth = 50
 

Typedef Documentation

Definition at line 108 of file arcsort.h.

typedef IntegerFilterState< signed char > fst::CharFilterState

Definition at line 88 of file filter-state.h.

template<class Arc , class Unsigned >
using fst::CompactAcceptorFst = typedef CompactArcFst<Arc, AcceptorCompactor<Arc>, U>

Definition at line 1601 of file compact-fst.h.

template<class Arc , class ArcCompactor , class Unsigned = uint32, class CompactStore = CompactArcStore<typename ArcCompactor::Element, Unsigned>, class CacheStore = DefaultCacheStore<Arc>>
using fst::CompactArcFst = typedef CompactFst<Arc, CompactArcCompactor<ArcCompactor, Unsigned, CompactStore>, CacheStore>

Definition at line 94 of file fst-decl.h.

template<class Arc , class Unsigned >
using fst::CompactStringFst = typedef CompactArcFst<Arc, StringCompactor<Arc>, U>

Definition at line 1594 of file compact-fst.h.

template<class Arc , class Unsigned >
using fst::CompactUnweightedAcceptorFst = typedef CompactArcFst<Arc, UnweightedAcceptorCompactor<Arc>, U>

Definition at line 1609 of file compact-fst.h.

template<class Arc , class Unsigned >
using fst::CompactUnweightedFst = typedef CompactArcFst<Arc, UnweightedCompactor<Arc>, U>

Definition at line 1605 of file compact-fst.h.

template<class Arc , class Unsigned >
using fst::CompactWeightedStringFst = typedef CompactArcFst<Arc, WeightedStringCompactor<Arc>, U>

Definition at line 1598 of file compact-fst.h.

Definition at line 176 of file concat.h.

template<class Expander >
using fst::DefaultExpanderCache = typedef VectorExpanderCache<typename Expander::Arc>

Definition at line 237 of file expander-cache.h.

Definition at line 146 of file difference.h.

using fst::ErrorArc = typedef ArcTpl<ErrorWeight>

Definition at line 81 of file arc.h.

typedef FloatWeightTpl< float > fst::FloatWeight

Definition at line 106 of file float-weight.h.

template<class Arc >
using fst::FstList = typedef std::vector<std::pair<typename Arc::Label, const Fst<Arc> *>>

Definition at line 396 of file replace.h.

Definition at line 167 of file phi-fst.h.

Definition at line 154 of file rho-fst.h.

Definition at line 157 of file sigma-fst.h.

Definition at line 54 of file map.h.

Definition at line 34 of file intersect.h.

Definition at line 90 of file filter-state.h.

template<class W >
using fst::IsIdempotent = typedef std::integral_constant<bool, (W::Properties() & kIdempotent) != 0>

Definition at line 157 of file weight.h.

template<class W >
using fst::IsPath = typedef std::integral_constant<bool, (W::Properties() & kPath) != 0>

Definition at line 160 of file weight.h.

using fst::Log64Arc = typedef ArcTpl<Log64Weight>

Definition at line 76 of file arc.h.

Definition at line 843 of file arc-map.h.

Definition at line 841 of file arc-map.h.

using fst::Log64Weight = typedef LogWeightTpl<double>

Definition at line 464 of file float-weight.h.

Definition at line 75 of file arc.h.

Definition at line 839 of file arc-map.h.

Definition at line 833 of file arc-map.h.

typedef LogWeightTpl< float > fst::LogWeight

Definition at line 461 of file float-weight.h.

template<typename T >
using fst::MemoryArena = typedef internal::MemoryArenaImpl<sizeof(T)>

Definition at line 93 of file memory.h.

Definition at line 82 of file arc.h.

Definition at line 904 of file float-weight.h.

Definition at line 175 of file phi-fst.h.

Definition at line 162 of file rho-fst.h.

Definition at line 165 of file sigma-fst.h.

template<class Arc >
using fst::PhiFst = typedef MatcherFst<ConstFst<Arc>, PhiFstMatcher<SortedMatcher<ConstFst<Arc>>>, phi_fst_type>

Definition at line 159 of file phi-fst.h.

Definition at line 36 of file rational.h.

Definition at line 70 of file lock.h.

Definition at line 78 of file arc.h.

using fst::Real64Weight = typedef RealWeightTpl<double>

Definition at line 707 of file float-weight.h.

using fst::RealArc = typedef ArcTpl<RealWeight>

Definition at line 77 of file arc.h.

using fst::RealWeight = typedef RealWeightTpl<float>

Definition at line 704 of file float-weight.h.

Definition at line 199 of file relabel.h.

template<class Arc >
using fst::RhoFst = typedef MatcherFst<ConstFst<Arc>, RhoFstMatcher<SortedMatcher<ConstFst<Arc>>>, rho_fst_type>

Definition at line 146 of file rho-fst.h.

Definition at line 89 of file filter-state.h.

template<class Arc >
using fst::SigmaFst = typedef MatcherFst<ConstFst<Arc>, SigmaFstMatcher<SortedMatcher<ConstFst<Arc>>>, sigma_fst_type>

Definition at line 149 of file sigma-fst.h.

Definition at line 80 of file arc.h.

using fst::SignedLog64Weight = typedef SignedLogWeightTpl<double>

Definition at line 320 of file signed-log-weight.h.

Definition at line 79 of file arc.h.

using fst::SignedLogWeight = typedef SignedLogWeightTpl<float>

Definition at line 317 of file signed-log-weight.h.

Definition at line 168 of file state-map.h.

Definition at line 74 of file arc.h.

Definition at line 350 of file matcher-fst.h.

Definition at line 138 of file randgen.h.

template<class Compare >
using fst::StdArcSortFst = typedef ArcSortFst<StdArc, Compare>

Definition at line 221 of file arcsort.h.

Definition at line 623 of file state-map.h.

Definition at line 625 of file state-map.h.

Definition at line 146 of file closure.h.

Definition at line 1615 of file compact-fst.h.

Definition at line 1611 of file compact-fst.h.

Definition at line 1620 of file compact-fst.h.

Definition at line 1617 of file compact-fst.h.

Definition at line 1613 of file compact-fst.h.

Definition at line 289 of file complement.h.

Definition at line 941 of file compose.h.

Definition at line 241 of file concat.h.

Definition at line 475 of file const-fst.h.

Definition at line 605 of file encode.h.

Definition at line 1031 of file determinize.h.

Definition at line 149 of file difference.h.

Definition at line 603 of file encode.h.

Definition at line 122 of file expanded-fst.h.

typedef Fst< StdArc > fst::StdFst

Definition at line 213 of file fst-decl.h.

Definition at line 223 of file arcsort.h.

Definition at line 367 of file matcher-fst.h.

Definition at line 169 of file phi-fst.h.

Definition at line 156 of file rho-fst.h.

Definition at line 159 of file sigma-fst.h.

Definition at line 232 of file fst-decl.h.

Definition at line 234 of file fst-decl.h.

Definition at line 214 of file fst-decl.h.

Definition at line 225 of file arcsort.h.

Definition at line 373 of file matcher-fst.h.

Definition at line 177 of file phi-fst.h.

Definition at line 164 of file rho-fst.h.

Definition at line 167 of file sigma-fst.h.

using fst::StdPhiFst = typedef PhiFst<StdArc>

Definition at line 161 of file phi-fst.h.

Definition at line 236 of file fst-decl.h.

Definition at line 238 of file fst-decl.h.

Definition at line 240 of file fst-decl.h.

using fst::StdRhoFst = typedef RhoFst<StdArc>

Definition at line 148 of file rho-fst.h.

Definition at line 242 of file fst-decl.h.

using fst::StdSigmaFst = typedef SigmaFst<StdArc>

Definition at line 151 of file sigma-fst.h.

Definition at line 269 of file string.h.

Definition at line 367 of file string.h.

Definition at line 837 of file arc-map.h.

Definition at line 831 of file arc-map.h.

Definition at line 244 of file fst-decl.h.

Definition at line 215 of file fst-decl.h.

Definition at line 40 of file synchronize.h.

Definition at line 260 of file float-weight.h.

Definition at line 115 of file union.h.

Enumeration Type Documentation

Enumerator
CLOSURE_STAR 
CLOSURE_PLUS 

Definition at line 39 of file rational.h.

Enumerator
AUTO_FILTER 
NULL_FILTER 
TRIVIAL_FILTER 
SEQUENCE_FILTER 
ALT_SEQUENCE_FILTER 
MATCH_FILTER 
NO_MATCH_FILTER 

Definition at line 943 of file compose.h.

Enumerator
DETERMINIZE_FUNCTIONAL 
DETERMINIZE_NONFUNCTIONAL 
DETERMINIZE_DISAMBIGUATE 

Definition at line 373 of file determinize.h.

Enumerator
DIVIDE_LEFT 
DIVIDE_RIGHT 
DIVIDE_ANY 

Definition at line 163 of file weight.h.

Enumerator
ENCODE 
DECODE 

Definition at line 39 of file encode.h.

Enumerator
EPS_NORM_INPUT 
EPS_NORM_OUTPUT 

Definition at line 32 of file epsnormalize.h.

enum fst::FarEntryType
strong
Enumerator
LINE 
FILE 

Definition at line 37 of file far.h.

enum fst::FarType
strong
Enumerator
DEFAULT 
STTABLE 
STLIST 
FST 

Definition at line 92 of file far.h.

Enumerator
GALLIC_LEFT 
GALLIC_RIGHT 
GALLIC_RESTRICT 
GALLIC_MIN 
GALLIC 

Definition at line 547 of file string-weight.h.

Enumerator
HS_STL 
HS_FLAT 

Definition at line 114 of file bi-table.h.

Enumerator
MAP_NO_SUPERFINAL 
MAP_ALLOW_SUPERFINAL 
MAP_REQUIRE_SUPERFINAL 

Definition at line 39 of file arc-map.h.

Enumerator
MAP_CLEAR_SYMBOLS 
MAP_COPY_SYMBOLS 
MAP_NOOP_SYMBOLS 

Definition at line 54 of file arc-map.h.

Enumerator
MATCHER_REWRITE_AUTO 
MATCHER_REWRITE_ALWAYS 
MATCHER_REWRITE_NEVER 

Definition at line 580 of file matcher.h.

Enumerator
MATCH_INPUT 
MATCH_OUTPUT 
MATCH_BOTH 
MATCH_NONE 
MATCH_UNKNOWN 

Definition at line 193 of file fst.h.

enum fst::MPdtType : uint8
strong
Enumerator
READ_RESTRICT 
WRITE_RESTRICT 
NO_RESTRICT 

Definition at line 37 of file mpdt.h.

Enumerator
PAREN 
EXPAND 
EXPAND_PAREN 

Definition at line 451 of file compose.h.

enum fst::PdtParserType : uint8
strong
Enumerator
LEFT 
LEFT_SR 

Definition at line 59 of file replace.h.

enum fst::ProjectType
strong
Enumerator
INPUT 
OUTPUT 

Definition at line 31 of file project.h.

Enumerator
TRIVIAL_QUEUE 
FIFO_QUEUE 
LIFO_QUEUE 
SHORTEST_FIRST_QUEUE 
TOP_ORDER_QUEUE 
STATE_ORDER_QUEUE 
SCC_QUEUE 
AUTO_QUEUE 
OTHER_QUEUE 

Definition at line 71 of file queue.h.

Enumerator
REPLACE_LABEL_NEITHER 
REPLACE_LABEL_INPUT 
REPLACE_LABEL_OUTPUT 
REPLACE_LABEL_BOTH 

Definition at line 43 of file replace-util.h.

Enumerator
REWEIGHT_TO_INITIAL 
REWEIGHT_TO_FINAL 

Definition at line 33 of file reweight.h.

Enumerator
SET_INTERSECT_UNION 
SET_UNION_INTERSECT 
SET_INTERSECT_UNION_RESTRICT 
SET_BOOLEAN 

Definition at line 53 of file set-weight.h.

Enumerator
STRING_LEFT 
STRING_RIGHT 
STRING_RESTRICT 

Definition at line 47 of file string-weight.h.

enum fst::TokenType : uint8
strong
Enumerator
SYMBOL 
BYTE 
UTF8 

Definition at line 46 of file string.h.

Function Documentation

template<class Arc >
void fst::AccumulateStatesAndArcs ( const Fst< Arc > &  fst,
size_t *  nstate,
size_t *  narc,
size_t *  nfinal 
)

Definition at line 34 of file info.h.

template<typename A >
uint64 fst::AddArcProperties ( uint64  inprops,
typename A::StateId  s,
const A &  arc,
const A *  prev_arc 
)
template<typename Arc >
uint64 fst::AddArcProperties ( uint64  inprops,
typename Arc::StateId  s,
const Arc &  arc,
const Arc *  prev_arc 
)

Gets the properties for the MutableFst::AddArc method.

Parameters
inpropsthe current properties of the FST
sthe ID of the state to which an arc is being added.
arcthe arc being added to the state with the specified ID
prev_arcthe previously-added (or "last") arc of state s, or nullptr

Definition at line 440 of file properties.h.

bool fst::AddAuxiliarySymbols ( const std::string &  prefix,
int64  start_label,
int64  nlabels,
SymbolTable syms 
)

Definition at line 122 of file symbol-table-ops.cc.

uint64 fst::AddStateProperties ( uint64  inprops)
inline

Definition at line 398 of file properties.h.

int fst::AlignBufferWithOutputStream ( std::ostream &  strm,
std::ostringstream &  buffer,
size_t  align 
)

Definition at line 120 of file util.cc.

bool fst::AlignInput ( std::istream &  strm,
size_t  align = MappedFile::kArchAlignment 
)

Definition at line 91 of file util.cc.

bool fst::AlignOutput ( std::ostream &  strm,
size_t  align = MappedFile::kArchAlignment 
)

Definition at line 107 of file util.cc.

bool fst::ApproxEqual ( const ErrorWeight ,
const ErrorWeight ,
float   
)
inline

Definition at line 56 of file error-weight.h.

template<class W1 , class W2 >
bool fst::ApproxEqual ( const PairWeight< W1, W2 > &  w1,
const PairWeight< W1, W2 > &  w2,
float  delta = kDelta 
)
inline

Definition at line 116 of file pair-weight.h.

template<class W , size_t n>
bool fst::ApproxEqual ( const TupleWeight< W, n > &  w1,
const TupleWeight< W, n > &  w2,
float  delta = kDelta 
)
inline

Definition at line 139 of file tuple-weight.h.

template<class T >
constexpr bool fst::ApproxEqual ( const FloatWeightTpl< T > &  w1,
const FloatWeightTpl< T > &  w2,
float  delta = kDelta 
)

Definition at line 157 of file float-weight.h.

template<class W , class K >
bool fst::ApproxEqual ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2,
float  delta = kDelta 
)
inline

Definition at line 167 of file sparse-power-weight.h.

template<class T >
bool fst::ApproxEqual ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2,
float  delta = kDelta 
)
inline

Definition at line 198 of file signed-log-weight.h.

template<class T >
bool fst::ApproxEqual ( const LogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2,
float  delta = kDelta 
)
inline

Definition at line 281 of file signed-log-weight.h.

template<class T >
bool fst::ApproxEqual ( const SignedLogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2,
float  delta = kDelta 
)
inline

Definition at line 287 of file signed-log-weight.h.

template<typename Label , StringType S>
bool fst::ApproxEqual ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2,
float  delta = kDelta 
)
inline

Definition at line 302 of file string-weight.h.

template<typename Label , SetType S>
bool fst::ApproxEqual ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2,
float  delta = kDelta 
)
inline

Definition at line 333 of file set-weight.h.

template<class W , class O >
bool fst::ApproxEqual ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2,
float  delta = kDelta 
)
inline

Definition at line 361 of file union-weight.h.

template<class A , class C >
void fst::ArcMap ( MutableFst< A > *  fst,
C *  mapper 
)

Definition at line 109 of file arc-map.h.

template<class A , class C >
void fst::ArcMap ( MutableFst< A > *  fst,
mapper 
)

Definition at line 187 of file arc-map.h.

template<class A , class B , class C >
void fst::ArcMap ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
C *  mapper 
)

Definition at line 195 of file arc-map.h.

template<class A , class B , class C >
void fst::ArcMap ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
mapper 
)

Definition at line 283 of file arc-map.h.

template<class Arc , class Compare >
void fst::ArcSort ( MutableFst< Arc > *  fst,
Compare  comp 
)

Definition at line 103 of file arcsort.h.

template<class Dest , class Source >
Dest fst::bit_cast ( const Source &  source)
inline

Definition at line 62 of file compat.h.

template<class Label >
bool fst::ByteStringToLabels ( const std::string &  str,
std::vector< Label > *  labels 
)

Definition at line 39 of file icu.h.

template<class F , class G >
void fst::Cast ( const F &  ,
G *   
)
template<class IFST , class OFST >
void fst::Cast ( const IFST &  ifst,
OFST *  ofst 
)

Definition at line 1052 of file fst.h.

template<class Arc >
void fst::Closure ( MutableFst< Arc > *  fst,
ClosureType  closure_type 
)

Definition at line 48 of file closure.h.

template<class Arc >
void fst::Closure ( RationalFst< Arc > *  fst,
ClosureType  closure_type 
)

Definition at line 72 of file closure.h.

uint64 fst::ClosureProperties ( uint64  inprops,
bool  star,
bool  delayed = false 
)

Definition at line 38 of file properties.cc.

SymbolTable * fst::CompactSymbolTable ( const SymbolTable syms)

Definition at line 77 of file symbol-table-ops.cc.

bool fst::CompatSymbols ( const SymbolTable syms1,
const SymbolTable syms2,
bool  warning = true 
)

Definition at line 409 of file symbol-table.cc.

uint64 fst::ComplementProperties ( uint64  inprops)

Definition at line 60 of file properties.cc.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const MPdtComposeOptions opts = MPdtComposeOptions() 
)

Definition at line 241 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
MutableFst< Arc > *  ofst,
const MPdtComposeOptions opts = MPdtComposeOptions() 
)

Definition at line 265 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const PdtComposeOptions opts = PdtComposeOptions() 
)

Definition at line 472 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
MutableFst< Arc > *  ofst,
const PdtComposeOptions opts = PdtComposeOptions() 
)

Definition at line 493 of file compose.h.

template<class Arc >
void fst::Compose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const ComposeOptions opts = ComposeOptions() 
)

Definition at line 995 of file compose.h.

uint64 fst::ComposeProperties ( uint64  inprops1,
uint64  inprops2 
)

Definition at line 73 of file properties.cc.

template<class Arc >
void fst::Compress ( const Fst< Arc > &  fst,
std::ostream &  strm 
)

Definition at line 739 of file compress.h.

template<class Arc >
bool fst::Compress ( const Fst< Arc > &  fst,
const std::string &  source 
)

Definition at line 745 of file compress.h.

template<class Arc >
Arc::Weight fst::ComputeTotalWeight ( const Fst< Arc > &  fst,
const std::vector< typename Arc::Weight > &  distance,
bool  reverse 
)

Definition at line 42 of file push.h.

template<class Arc >
void fst::Concat ( MutableFst< Arc > *  fst1,
const Fst< Arc > &  fst2 
)

Definition at line 49 of file concat.h.

template<class Arc >
void fst::Concat ( RationalFst< Arc > *  fst1,
const Fst< Arc > &  fst2 
)

Definition at line 100 of file concat.h.

template<class Arc >
void fst::Concat ( const Fst< Arc > &  fst1,
MutableFst< Arc > *  fst2 
)

Definition at line 115 of file concat.h.

template<class Arc >
void fst::Concat ( const std::vector< const Fst< Arc > * > &  fsts1,
MutableFst< Arc > *  fst2 
)

Definition at line 164 of file concat.h.

template<class Arc >
void fst::Concat ( const Fst< Arc > &  fst1,
RationalFst< Arc > *  fst2 
)

Definition at line 172 of file concat.h.

uint64 fst::ConcatProperties ( uint64  inprops1,
uint64  inprops2,
bool  delayed = false 
)

Definition at line 95 of file properties.cc.

template<class Arc >
void fst::Condense ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
std::vector< typename Arc::StateId > *  scc 
)

Definition at line 298 of file connect.h.

template<class Arc >
void fst::Connect ( MutableFst< Arc > *  fst)

Definition at line 278 of file connect.h.

template<class Arc >
Fst<Arc>* fst::Convert ( const Fst< Arc > &  fst,
const std::string &  fst_type 
)

Definition at line 121 of file register.h.

void fst::ConvertToLegalCSymbol ( std::string *  s)

Definition at line 81 of file util.cc.

template<class F >
size_t fst::CountArcs ( const F &  fst)

Definition at line 193 of file expanded-fst.h.

template<class Arc >
Arc::StateId fst::CountStates ( const Fst< Arc > &  fst)

Definition at line 169 of file expanded-fst.h.

template<class Arc >
Arc::StateId fst::CountStates ( const std::vector< const Fst< Arc > * > &  fsts)

Definition at line 185 of file expanded-fst.h.

template<class Arc >
void fst::Decode ( MutableFst< Arc > *  fst,
const EncodeMapper< Arc > &  mapper 
)
inline

Definition at line 479 of file encode.h.

template<class Arc >
bool fst::Decompress ( std::istream &  strm,
const std::string &  source,
MutableFst< Arc > *  fst 
)

Definition at line 760 of file compress.h.

template<class Arc >
bool fst::Decompress ( const std::string &  source,
MutableFst< Arc > *  fst 
)

Definition at line 769 of file compress.h.

uint64 fst::DeleteAllStatesProperties ( uint64  inprops,
uint64  staticProps 
)
inline

Definition at line 406 of file properties.h.

uint64 fst::DeleteArcsProperties ( uint64  inprops)
inline

Definition at line 411 of file properties.h.

uint64 fst::DeleteStatesProperties ( uint64  inprops)
inline

Definition at line 402 of file properties.h.

template<class FST >
void fst::Destroy ( ArcIterator< FST > *  aiter,
MemoryPool< ArcIterator< FST >> *  pool 
)

Definition at line 594 of file fst.h.

template<class Arc >
void fst::Determinize ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
const DeterminizeOptions< Arc > &  opts = DeterminizeOptions<Arc>() 
)

Definition at line 1078 of file determinize.h.

uint64 fst::DeterminizeProperties ( uint64  inprops,
bool  has_subsequential_label,
bool  distinct_psubsequential_labels 
)

Definition at line 130 of file properties.cc.

template<class FST , class Visitor , class ArcFilter >
void fst::DfsVisit ( const FST &  fst,
Visitor *  visitor,
ArcFilter  filter,
bool  access_only = false 
)

Definition at line 108 of file dfs-visit.h.

template<class Arc , class Visitor >
void fst::DfsVisit ( const Fst< Arc > &  fst,
Visitor *  visitor 
)

Definition at line 212 of file dfs-visit.h.

template<class Arc >
void fst::Difference ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const DifferenceOptions opts = DifferenceOptions() 
)

Definition at line 165 of file difference.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Difference ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 444 of file set-weight.h.

template<class Arc >
void fst::Disambiguate ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
const DisambiguateOptions< Arc > &  opts = DisambiguateOptions<Arc>() 
)

Definition at line 578 of file disambiguate.h.

ErrorWeight fst::Divide ( const ErrorWeight ,
const ErrorWeight  
)
inline

Definition at line 65 of file error-weight.h.

template<class W1 , class W2 >
ProductWeight<W1, W2> fst::Divide ( const ProductWeight< W1, W2 > &  w1,
const ProductWeight< W1, W2 > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 100 of file product-weight.h.

template<class W , size_t n>
PowerWeight<W, n> fst::Divide ( const PowerWeight< W, n > &  w1,
const PowerWeight< W, n > &  w2,
DivideType  type = DIVIDE_ANY 
)
inline

Definition at line 121 of file power-weight.h.

template<class W1 , class W2 >
LexicographicWeight<W1, W2> fst::Divide ( const LexicographicWeight< W1, W2 > &  w,
const LexicographicWeight< W1, W2 > &  v,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 135 of file lexicographic-weight.h.

template<class W1 , class W2 >
ExpectationWeight<W1, W2> fst::Divide ( const ExpectationWeight< W1, W2 > &  w1,
const ExpectationWeight< W1, W2 > &  w2,
DivideType  typ 
)
inline

Definition at line 142 of file expectation-weight.h.

template<class W , class K >
SparsePowerWeight<W, K> fst::Divide ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2,
DivideType  type = DIVIDE_ANY 
)
inline

Definition at line 145 of file sparse-power-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Divide ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 175 of file signed-log-weight.h.

template<class W , class K >
SparsePowerWeight<W, K> fst::Divide ( const SparsePowerWeight< W, K > &  w1,
const W &  k,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 194 of file sparse-power-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Divide ( const LogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 267 of file signed-log-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Divide ( const SignedLogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)
inline

Definition at line 274 of file signed-log-weight.h.

template<class T >
constexpr TropicalWeightTpl<T> fst::Divide ( const TropicalWeightTpl< T > &  w1,
const TropicalWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 317 of file float-weight.h.

constexpr TropicalWeightTpl<float> fst::Divide ( const TropicalWeightTpl< float > &  w1,
const TropicalWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 347 of file float-weight.h.

constexpr TropicalWeightTpl<double> fst::Divide ( const TropicalWeightTpl< double > &  w1,
const TropicalWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 353 of file float-weight.h.

template<class W , class O >
UnionWeight<W, O> fst::Divide ( const UnionWeight< W, O > &  w1,
const UnionWeight< W, O > &  w2,
DivideType  typ 
)
inline

Definition at line 462 of file union-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::Divide ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2,
DivideType  divide_type 
)
inline

Definition at line 463 of file string-weight.h.

template<typename Label >
StringWeight<Label, STRING_LEFT> fst::Divide ( const StringWeight< Label, STRING_LEFT > &  w1,
const StringWeight< Label, STRING_LEFT > &  w2,
DivideType  divide_type 
)
inline

Definition at line 481 of file string-weight.h.

template<typename Label >
StringWeight<Label, STRING_RIGHT> fst::Divide ( const StringWeight< Label, STRING_RIGHT > &  w1,
const StringWeight< Label, STRING_RIGHT > &  w2,
DivideType  divide_type 
)
inline

Definition at line 494 of file string-weight.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Divide ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 547 of file set-weight.h.

template<typename Label >
SetWeight<Label, SET_UNION_INTERSECT> fst::Divide ( const SetWeight< Label, SET_UNION_INTERSECT > &  w1,
const SetWeight< Label, SET_UNION_INTERSECT > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 556 of file set-weight.h.

template<typename Label >
SetWeight<Label, SET_BOOLEAN> fst::Divide ( const SetWeight< Label, SET_BOOLEAN > &  w1,
const SetWeight< Label, SET_BOOLEAN > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 568 of file set-weight.h.

template<class T >
constexpr LogWeightTpl<T> fst::Divide ( const LogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 575 of file float-weight.h.

constexpr LogWeightTpl<float> fst::Divide ( const LogWeightTpl< float > &  w1,
const LogWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 583 of file float-weight.h.

constexpr LogWeightTpl<double> fst::Divide ( const LogWeightTpl< double > &  w1,
const LogWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 589 of file float-weight.h.

template<class Label , class W , GallicType G>
GallicWeight<Label, W, G> fst::Divide ( const GallicWeight< Label, W, G > &  w,
const GallicWeight< Label, W, G > &  v,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 652 of file string-weight.h.

template<class T >
constexpr RealWeightTpl<T> fst::Divide ( const RealWeightTpl< T > &  w1,
const RealWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 779 of file float-weight.h.

constexpr RealWeightTpl<float> fst::Divide ( const RealWeightTpl< float > &  w1,
const RealWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 786 of file float-weight.h.

constexpr RealWeightTpl<double> fst::Divide ( const RealWeightTpl< double > &  w1,
const RealWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 792 of file float-weight.h.

template<class Label , class W >
GallicWeight<Label, W, GALLIC> fst::Divide ( const GallicWeight< Label, W, GALLIC > &  w1,
const GallicWeight< Label, W, GALLIC > &  w2,
DivideType  divide_type = DIVIDE_ANY 
)
inline

Definition at line 796 of file string-weight.h.

template<class T >
constexpr MinMaxWeightTpl<T> fst::Divide ( const MinMaxWeightTpl< T > &  w1,
const MinMaxWeightTpl< T > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 944 of file float-weight.h.

constexpr MinMaxWeightTpl<float> fst::Divide ( const MinMaxWeightTpl< float > &  w1,
const MinMaxWeightTpl< float > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 950 of file float-weight.h.

constexpr MinMaxWeightTpl<double> fst::Divide ( const MinMaxWeightTpl< double > &  w1,
const MinMaxWeightTpl< double > &  w2,
DivideType  typ = DIVIDE_ANY 
)

Definition at line 956 of file float-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::DivideLeft ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 423 of file string-weight.h.

template<typename Label , StringType S>
StringWeight<Label, S> fst::DivideRight ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 443 of file string-weight.h.

template<class W , size_t n>
W fst::DotProduct ( const PowerWeight< W, n > &  w1,
const PowerWeight< W, n > &  w2 
)
inline

Definition at line 155 of file power-weight.h.

template<class W , class K >
const W& fst::DotProduct ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2 
)
inline

Definition at line 156 of file sparse-power-weight.h.

template<typename To , typename From >
To fst::down_cast ( From *  f)
inline

Definition at line 51 of file compat.h.

template<typename To , typename From >
To fst::down_cast ( From &  f)
inline

Definition at line 56 of file compat.h.

template<class Arc >
void fst::Encode ( MutableFst< Arc > *  fst,
EncodeMapper< Arc > *  mapper 
)
inline

Definition at line 472 of file encode.h.

bool fst::EpsilonOnInput ( ReplaceLabelType  label_type)
inline

Definition at line 399 of file replace.h.

bool fst::EpsilonOnOutput ( ReplaceLabelType  label_type)
inline

Definition at line 405 of file replace.h.

template<class Arc >
void fst::EpsNormalize ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
EpsNormalizeType  type = EPS_NORM_INPUT 
)

Definition at line 46 of file epsnormalize.h.

template<class Arc , GallicType G>
void fst::EpsNormalize ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst,
EpsNormalizeType  type 
)

Definition at line 53 of file epsnormalize.h.

template<class Arc , class WeightEqual >
bool fst::Equal ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
WeightEqual  weight_equal,
uint8  etype = kEqualFsts 
)

Definition at line 59 of file equal.h.

template<class Arc >
bool fst::Equal ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
float  delta = kDelta,
uint8  etype = kEqualFsts 
)

Definition at line 164 of file equal.h.

template<class Arc >
bool fst::Equal ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
double  delta,
uint8  etype = kEqualFsts 
)

Definition at line 174 of file equal.h.

template<class Arc >
bool fst::Equivalent ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
float  delta = kDelta,
bool *  error = nullptr 
)

Definition at line 129 of file equivalent.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
MutableFst< Arc > *  ofst,
const MPdtExpandOptions opts 
)

Definition at line 316 of file expand.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
const std::vector< typename Arc::Label > &  assignments,
MutableFst< Arc > *  ofst,
bool  connect = true,
bool  keep_parentheses = false 
)

Definition at line 338 of file expand.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
MutableFst< Arc > *  ofst,
const PdtExpandOptions< Arc > &  opts 
)

Definition at line 917 of file expand.h.

template<class Arc >
void fst::Expand ( const Fst< Arc > &  ifst,
const std::vector< std::pair< typename Arc::Label, typename Arc::Label >> &  parens,
MutableFst< Arc > *  ofst,
bool  connect = true,
bool  keep_parentheses = false 
)

Definition at line 946 of file expand.h.

uint64 fst::FactorWeightProperties ( uint64  inprops)

Definition at line 155 of file properties.cc.

template<class Arc >
void fst::FarCompileStrings ( const std::vector< std::string > &  in_sources,
const std::string &  out_source,
const std::string &  fst_type,
const FarType far_type,
int32  generate_keys,
FarEntryType  entry_type,
TokenType  token_type,
const std::string &  symbols_source,
const std::string &  unknown_symbol,
bool  keep_symbols,
bool  initial_symbols,
bool  allow_negative_labels,
const std::string &  key_prefix,
const std::string &  key_suffix 
)

Definition at line 138 of file compile-strings.h.

template<class Arc >
void fst::FarConvert ( const std::string &  in_source,
const std::string &  out_source,
const std::string &  fst_type,
const FarType far_type 
)

Definition at line 28 of file convert.h.

template<class Arc >
void fst::FarCreate ( const std::vector< std::string > &  in_sources,
const std::string &  out_source,
const int32  generate_keys,
const FarType far_type,
const std::string &  key_prefix,
const std::string &  key_suffix 
)

Definition at line 34 of file create.h.

template<class Arc >
bool fst::FarEqual ( const std::string &  source1,
const std::string &  source2,
float  delta = kDelta,
const std::string &  begin_key = std::string(),
const std::string &  end_key = std::string() 
)

Definition at line 30 of file equal.h.

template<class Arc >
void fst::FarExtract ( const std::vector< std::string > &  isources,
int32  generate_sources,
const std::string &  keys,
const std::string &  key_separator,
const std::string &  range_delimiter,
const std::string &  source_prefix,
const std::string &  source_suffix 
)

Definition at line 61 of file extract.h.

template<class Arc >
void fst::FarInfo ( const std::vector< std::string > &  sources,
const std::string &  begin_key,
const std::string &  end_key,
const bool  list_fsts 
)

Definition at line 101 of file info.h.

template<class Arc >
bool fst::FarIsomorphic ( const std::string &  source1,
const std::string &  source2,
float  delta = kDelta,
const std::string &  begin_key = std::string(),
const std::string &  end_key = std::string() 
)

Definition at line 30 of file isomorphic.h.

template<class Arc >
void fst::FarPrintStrings ( const std::vector< std::string > &  isources,
FarEntryType  entry_type,
TokenType  token_type,
const std::string &  begin_key,
const std::string &  end_key,
bool  print_key,
bool  print_weight,
const std::string &  symbols_source,
bool  initial_symbols,
int32  generate_sources,
const std::string &  source_prefix,
const std::string &  source_suffix 
)

Definition at line 38 of file print-strings.h.

template<class Arc >
void fst::FarWriteFst ( const Fst< Arc > *  fst,
std::string_view  key,
std::string *  okey,
int *  nrep,
int32  generate_sources,
int  i,
std::string_view  source_prefix,
std::string_view  source_suffix 
)
inline

Definition at line 35 of file extract.h.

template<class T >
constexpr bool fst::FloatApproxEqual ( w1,
w2,
float  delta = kDelta 
)

Definition at line 152 of file float-weight.h.

SymbolTable * fst::FstReadSymbols ( const std::string &  source,
bool  input 
)

Definition at line 88 of file symbol-table-ops.cc.

template<class Arc >
std::string fst::FstToString ( const Fst< Arc > &  fst,
const FstWriteOptions options = FstWriteOptions("FstToString") 
)

Definition at line 1061 of file fst.h.

template<class Arc >
void fst::FstToString ( const Fst< Arc > &  fst,
std::string *  result 
)

Definition at line 1070 of file fst.h.

template<class Arc >
void fst::FstToString ( const Fst< Arc > &  fst,
std::string *  result,
const FstWriteOptions options 
)

Definition at line 1075 of file fst.h.

constexpr StringType fst::GallicStringType ( GallicType  g)

Definition at line 555 of file string-weight.h.

template<class Arc >
void fst::GetFarInfo ( const std::vector< std::string > &  sources,
const std::string &  begin_key,
const std::string &  end_key,
const bool  list_fsts,
FarInfoData far_info 
)

Definition at line 65 of file info.h.

std::string fst::GetFarTypeString ( FarType  far_type)

Definition at line 64 of file getters.cc.

template<class A >
A::Label fst::GuessStartOrEnd ( std::vector< typename A::Label > *  sequence,
typename A::Label  boundary 
)

Definition at line 1049 of file linear-fst-data-builder.h.

template<typename To >
constexpr To fst::implicit_cast ( typename internal::identity_t< To >  to)

Definition at line 83 of file compat.h.

template<class Arc >
void fst::Intersect ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst,
const IntersectOptions opts = IntersectOptions() 
)

Definition at line 141 of file intersect.h.

template<typename Label , SetType S>
SetWeight<Label, S> fst::Intersect ( const SetWeight< Label, S > &  w1,
const SetWeight< Label, S > &  w2 
)
inline

Definition at line 415 of file set-weight.h.

template<class Arc >
void fst::Invert ( const Fst< Arc > &  ifst,
MutableFst< Arc > *  ofst 
)
inline

Definition at line 66 of file invert.h.

template<class Arc >
void fst::Invert ( MutableFst< Arc > *  fst)
inline

Definition at line 78 of file invert.h.

uint64 fst::InvertProperties ( uint64  inprops)

Definition at line 169 of file properties.cc.

bool fst::IsFst ( const std::string &  source)
inline

Definition at line 42 of file far.h.

template<class Arc >
bool fst::Isomorphic ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2,
float  delta = kDelta 
)

Definition at line 251 of file isomorphic.h.

bool fst::IsSTList ( const std::string &  source)

Definition at line 26 of file stlist.cc.

bool fst::IsSTTable ( const std::string &  source)

Definition at line 24 of file sttable.cc.

template<class Iterator >
std::string fst::JoinLabels ( Iterator  begin,
Iterator  end,
const SymbolTable syms 
)

Definition at line 1028 of file linear-fst-data-builder.h.

template<class Label >
std::string fst::JoinLabels ( const std::vector< Label > &  labels,
const SymbolTable syms 
)

Definition at line 1043 of file linear-fst-data-builder.h.

int fst::KeySize ( const char *  source)

Definition at line 33 of file strings.cc.

template<class Label >
bool fst::LabelsToByteString ( const std::vector< Label > &  labels,
std::string *  str 
)

Definition at line 91 of file icu.h.

template<class Label >
bool fst::LabelsToString ( const std::vector< Label > &  labels,
std::string *  str,
TokenType  ttype = TokenType::BYTE,
const SymbolTable syms = nullptr,
const std::string &  sep = FST_FLAGS_fst_field_separator,
bool  omit_epsilon = true 
)

Definition at line 314 of file string.h.

template<class Label >
bool fst::LabelsToUTF8String ( const std::vector< Label > &  labels,
std::string *  str 
)

Definition at line 101 of file icu.h.

template<class A >
void fst::LogLinearApply ( const Fst< A > &  ifst,
const Fst< A > &  lfst,
MutableFst< A > *  ofst,
bool  normalize = true 
)

Definition at line 50 of file loglinear-apply.h.

template<class A , class B >
void fst::LogLinearApply ( const Fst< A > &  ifst,
const Fst< A > &  lfst,
MutableFst< A > *  ofst,
bool  normalize = true 
)

Definition at line 59 of file loglinear-apply.h.

template<class Arc >
void fst::LookAheadCompose ( const Fst< Arc > &  ifst1,
const Fst< Arc > &  ifst2,
MutableFst< Arc > *  ofst 
)

Definition at line 66 of file algo_test.h.

void fst::LookAheadCompose ( const Fst< StdArc > &  ifst1,
const Fst< StdArc > &  ifst2,
MutableFst< StdArc > *  ofst 
)
inline

Definition at line 72 of file algo_test.h.

template<class Matcher1 , class Matcher2 >
MatchType fst::LookAheadMatchType ( const Matcher1 &  m1,
const Matcher2 &  m2 
)

Definition at line 40 of file lookahead-filter.h.

template<class Arc >
MatchType fst::LookAheadMatchType ( const Fst< Arc > &  fst1,
const Fst< Arc > &  fst2 
)

Definition at line 62 of file lookahead-filter.h.

template<typename T >
iterator_range<T> fst::make_range ( x,
y 
)

Definition at line 158 of file compat.h.

template<typename T >
std::unique_ptr<T> fst::make_unique_for_overwrite ( )

Definition at line 114 of file compat.h.

template<typename T >
std::unique_ptr<T[]> fst::make_unique_for_overwrite ( size_t  n)

Definition at line 119 of file compat.h.

template<class ArcMapper >
ArcMapFst<typename ArcMapper::FromArc, typename ArcMapper::ToArc, ArcMapper> fst::MakeArcMapFst ( const Fst< typename ArcMapper::FromArc > &  fst,
const ArcMapper &  mapper 
)

Definition at line 651 of file arc-map.h.

template<class ArcMapper >
ArcMapFst<typename ArcMapper::FromArc, typename ArcMapper::ToArc, ArcMapper> fst::MakeArcMapFst ( const Fst< typename ArcMapper::FromArc > &  fst,
ArcMapper *  mapper 
)

Definition at line 661 of file arc-map.h.

template<class Arc , class Unsigned = uint32, class LabelIterator >
CompactStringFst<Arc, Unsigned> fst::MakeCompactStringFst ( const LabelIterator  begin,
const LabelIterator  end 
)
inline

Definition at line 1625 of file compact-fst.h.

template<class LabelIterator >
StdCompactStringFst fst::MakeStdCompactStringFst ( const LabelIterator  begin,
const LabelIterator  end 
)
inline

Definition at line 1633 of file compact-fst.h.

template<class A , class C >
void fst::Map ( MutableFst< A > *  fst,
C *  mapper 
)

Definition at line 31 of file map.h.

template<class A , class C >
void fst::Map ( MutableFst< A > *  fst,
mapper 
)

Definition at line 37 of file map.h.

template<class A , class B , class C >
void fst::Map ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
C *  mapper 
)

Definition at line 43 of file map.h.

template<class A , class B , class C >
void fst::Map ( const Fst< A > &  ifst,
MutableFst< B > *  ofst,
mapper 
)

Definition at line 49 of file map.h.

SymbolTable * fst::MergeSymbolTable ( const SymbolTable left,
const SymbolTable right,
bool *  right_relabel_output = nullptr 
)

Definition at line 25 of file symbol-table-ops.cc.

template<class Arc >
void fst::Minimize ( MutableFst< Arc > *  fst,
MutableFst< Arc > *  sfst = nullptr,
float  delta = kShortestDelta,
bool  allow_nondet = false 
)

Definition at line 505 of file minimize.h.

template<class W , class K >
SparsePowerWeight<W, K> fst::Minus ( const SparsePowerWeight< W, K > &  w1,
const SparsePowerWeight< W, K > &  w2 
)
inline

Definition at line 127 of file sparse-power-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Minus ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 152 of file signed-log-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Minus ( const LogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 243 of file signed-log-weight.h.

template<class T >
SignedLogWeightTpl<T> fst::Minus ( const SignedLogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2 
)
inline

Definition at line 249 of file signed-log-weight.h.

template<class T >
LogWeightTpl<T> fst::Minus ( const LogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2 
)
inline

Definition at line 535 of file float-weight.h.

LogWeightTpl<float> fst::Minus ( const LogWeightTpl< float > &  w1,
const LogWeightTpl< float > &  w2 
)
inline

Definition at line 547 of file float-weight.h.

LogWeightTpl<double> fst::Minus ( const LogWeightTpl< double > &  w1,
const LogWeightTpl< double > &  w2 
)
inline

Definition at line 552 of file float-weight.h.

template<class T >
RealWeightTpl<T> fst::Minus ( const RealWeightTpl< T > &  w1,
const RealWeightTpl< T > &  w2 
)
inline

Definition at line 743 of file float-weight.h.

RealWeightTpl<float> fst::Minus ( const RealWeightTpl< float > &  w1,
const RealWeightTpl< float > &  w2 
)
inline

Definition at line 751 of file float-weight.h.

RealWeightTpl<double> fst::Minus ( const RealWeightTpl< double > &  w1,
const RealWeightTpl< double > &  w2 
)
inline

Definition at line 756 of file float-weight.h.

uint64 fst::MPdtExpandProperties ( uint64  inprops)
inline

Definition at line 51 of file expand.h.

uint32 fst::nth_bit ( const uint64  v,
uint32  r 
)

Definition at line 234 of file nthbit.cc.

template<class Result , class RNG >
void fst::OneMultinomialSample ( const std::vector< double > &  probs,
size_t  num_to_sample,
Result *  result,
RNG *  rng 
)

Definition at line 275 of file randgen.h.

class fst::OPENFST_DEPRECATED ( "Use SymbolTable::iterator  ,
a C++compliant  iterator,
instead  
)

Definition at line 522 of file symbol-table.h.

bool fst::operator!= ( const ErrorWeight ,
const ErrorWeight  
)
inline

Definition at line 52 of file error-weight.h.

template<class W1 , class W2 >
bool fst::operator!= ( const PairWeight< W1, W2 > &  w1,
const PairWeight< W1, W2 > &  w2 
)
inline

Definition at line 110 of file pair-weight.h.

template<class W , size_t n>
bool fst::operator!= ( const TupleWeight< W, n > &  w1,
const TupleWeight< W, n > &  w2 
)
inline

Definition at line 130 of file tuple-weight.h.

template<class T >
constexpr bool fst::operator!= ( const FloatWeightTpl< T > &  w1,
const FloatWeightTpl< T > &  w2 
)

Definition at line 136 of file float-weight.h.

constexpr bool fst::operator!= ( const FloatWeightTpl< float > &  w1,
const FloatWeightTpl< float > &  w2 
)

Definition at line 141 of file float-weight.h.

constexpr bool fst::operator!= ( const FloatWeightTpl< double > &  w1,
const FloatWeightTpl< double > &  w2 
)

Definition at line 146 of file float-weight.h.

template<class T >
bool fst::operator!= ( const SignedLogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 221 of file signed-log-weight.h.

template<typename T , typename U >
bool fst::operator!= ( const BlockAllocator< T > &  alloc1,
const BlockAllocator< U > &  alloc2 
)

Definition at line 295 of file memory.h.

template<typename Label , StringType S>
bool fst::operator!= ( const StringWeight< Label, S > &  w1,
const StringWeight< Label, S > &  w2 
)
inline

Definition at line 296 of file string-weight.h.

template<class T >
bool fst::operator!= ( const LogWeightTpl< T > &  w1,
const SignedLogWeightTpl< T > &  w2 
)
inline

Definition at line 305 of file signed-log-weight.h.

template<class T >
bool fst::operator!= ( const SignedLogWeightTpl< T > &  w1,
const LogWeightTpl< T > &  w2 
)
inline

Definition at line 311 of file signed-log-weight.h.