src/include/fst/script/rmepsilon.h

   1 // See www.openfst.org for extensive documentation on this weighted
   2 // finite-state transducer library.
   3
   4 #ifndef FST_SCRIPT_RMEPSILON_H_
   5 #define FST_SCRIPT_RMEPSILON_H_
   6
   7 #include <utility>
   8 #include <vector>
   9
  10 #include <fst/queue.h>
  11 #include <fst/rmepsilon.h>
  12 #include <fst/script/fst-class.h>
  13 #include <fst/script/shortest-distance.h>
  14 #include <fst/script/weight-class.h>
  15
  16 namespace fst {
  17 namespace script {
  18
  19
  20 struct RmEpsilonOptions : public ShortestDistanceOptions {
  21   const bool connect;
  22   const WeightClass &weight_threshold;
  23   const int64 state_threshold;
  24
  25   RmEpsilonOptions(QueueType queue_type, bool connect,
  26                    const WeightClass &weight_threshold,
  27                    int64 state_threshold = kNoStateId,
  28                    float delta = kDelta)
  29       : ShortestDistanceOptions(queue_type, EPSILON_ARC_FILTER, kNoStateId,
  30                                 delta),
  31         connect(connect),
  32         weight_threshold(weight_threshold),
  33         state_threshold(state_threshold) {}
  34 };
  35
  36 namespace internal {
  37
  38 // Code to implement switching on queue types.
  39
  40 template <class Arc, class Queue>
  41 void RmEpsilon(MutableFst<Arc> *fst,
  42                std::vector<typename Arc::Weight> *distance,
  43                const RmEpsilonOptions &opts,
  44                Queue *queue) {
  45   using Weight = typename Arc::Weight;
  46   const fst::RmEpsilonOptions<Arc, Queue> ropts(queue, opts.delta,
  47       opts.connect, *opts.weight_threshold.GetWeight<Weight>(),
  48       opts.state_threshold);
  49   RmEpsilon(fst, distance, ropts);
  50 }
  51
  52 template <class Arc>
  53 void RmEpsilon(MutableFst<Arc> *fst,
  54                const RmEpsilonOptions &opts) {
  55   using StateId = typename Arc::StateId;
  56   using Weight = typename Arc::Weight;
  57   std::vector<Weight> distance;
  58   switch (opts.queue_type) {
  59     case AUTO_QUEUE: {
  60       AutoQueue<StateId> queue(*fst, &distance, EpsilonArcFilter<Arc>());
  61       RmEpsilon(fst, &distance, opts, &queue);
  62       return;
  63     }
  64     case FIFO_QUEUE: {
  65       FifoQueue<StateId> queue;
  66       RmEpsilon(fst, &distance, opts, &queue);
  67       return;
  68     }
  69     case LIFO_QUEUE: {
  70       LifoQueue<StateId> queue;
  71       RmEpsilon(fst, &distance, opts, &queue);
  72       return;
  73     }
  74     case SHORTEST_FIRST_QUEUE: {
  75       NaturalShortestFirstQueue<StateId, Weight> queue(distance);
  76       RmEpsilon(fst, &distance, opts, &queue);
  77       return;
  78     }
  79     case STATE_ORDER_QUEUE: {
  80       StateOrderQueue<StateId> queue;
  81       RmEpsilon(fst, &distance, opts, &queue);
  82       return;
  83     }
  84     case TOP_ORDER_QUEUE: {
  85       TopOrderQueue<StateId> queue(*fst, EpsilonArcFilter<Arc>());
  86       internal::RmEpsilon(fst, &distance, opts, &queue);
  87       return;
  88     }
  89     default: {
  90       FSTERROR() << "RmEpsilon: Unknown queue type: "
  91                  << opts.queue_type;
  92       fst->SetProperties(kError, kError);
  93       return;
  94     }
  95   }
  96 }
  97
  98 }  // namespace internal
  99
 100 using RmEpsilonArgs = std::pair<MutableFstClass *, const RmEpsilonOptions &>;
 101
 102 template <class Arc>
 103 void RmEpsilon(RmEpsilonArgs *args) {
 104   MutableFst<Arc> *fst = std::get<0>(*args)->GetMutableFst<Arc>();
 105   const auto &opts = std::get<1>(*args);
 106   internal::RmEpsilon(fst, opts);
 107 }
 108
 109 void RmEpsilon(MutableFstClass *fst, const RmEpsilonOptions &opts);
 110
 111 }  // namespace script
 112 }  // namespace fst
 113
 114 #endif  // FST_SCRIPT_RMEPSILON_H_