src/include/fst/script/map.h

   1 // See www.openfst.org for extensive documentation on this weighted
   2 // finite-state transducer library.
   3
   4 #ifndef FST_SCRIPT_MAP_H_
   5 #define FST_SCRIPT_MAP_H_
   6
   7 #include <memory>
   8 #include <tuple>
   9
  10 #include <fst/arc-map.h>
  11 #include <fst/state-map.h>
  12 #include <fst/script/arg-packs.h>
  13 #include <fst/script/fst-class.h>
  14 #include <fst/script/weight-class.h>
  15
  16 namespace fst {
  17 namespace script {
  18
  19 template <class M>
  20 Fst<typename M::ToArc> *ArcMap(const Fst<typename M::FromArc> &fst,
  21                                const M &mapper) {
  22   using ToArc = typename M::ToArc;
  23   auto *ofst = new VectorFst<ToArc>;
  24   ArcMap(fst, ofst, mapper);
  25   return ofst;
  26 }
  27
  28 template <class M>
  29 Fst<typename M::ToArc> *StateMap(const Fst<typename M::FromArc> &fst,
  30                                  const M &mapper) {
  31   using ToArc = typename M::ToArc;
  32   auto *ofst = new VectorFst<ToArc>;
  33   StateMap(fst, ofst, mapper);
  34   return ofst;
  35 }
  36
  37 enum MapType {
  38   ARC_SUM_MAPPER,
  39   ARC_UNIQUE_MAPPER,
  40   IDENTITY_MAPPER,
  41   INPUT_EPSILON_MAPPER,
  42   INVERT_MAPPER,
  43   OUTPUT_EPSILON_MAPPER,
  44   PLUS_MAPPER,
  45   QUANTIZE_MAPPER,
  46   RMWEIGHT_MAPPER,
  47   SUPERFINAL_MAPPER,
  48   TIMES_MAPPER,
  49   TO_LOG_MAPPER,
  50   TO_LOG64_MAPPER,
  51   TO_STD_MAPPER
  52 };
  53
  54 using MapInnerArgs = std::tuple<const FstClass &, MapType, float,
  55                                 const WeightClass &>;
  56
  57 using MapArgs = WithReturnValue<FstClass *, MapInnerArgs>;
  58
  59 template <class Arc>
  60 void Map(MapArgs *args) {
  61   using Weight = typename Arc::Weight;
  62   const Fst<Arc> &ifst = *(std::get<0>(args->args).GetFst<Arc>());
  63   const auto map_type = std::get<1>(args->args);
  64   const auto weight = *(std::get<3>(args->args).GetWeight<Weight>());
  65   switch (map_type) {
  66     case ARC_SUM_MAPPER: {
  67       std::unique_ptr<Fst<Arc>> ofst(StateMap(ifst, ArcSumMapper<Arc>(ifst)));
  68       args->retval = new FstClass(*ofst);
  69       return;
  70     }
  71     case ARC_UNIQUE_MAPPER: {
  72       std::unique_ptr<Fst<Arc>> ofst(StateMap(ifst,
  73                                               ArcUniqueMapper<Arc>(ifst)));
  74       args->retval = new FstClass(*ofst);
  75       return;
  76     }
  77     case IDENTITY_MAPPER: {
  78       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, IdentityArcMapper<Arc>()));
  79       args->retval = new FstClass(*ofst);
  80       return;
  81     }
  82     case INPUT_EPSILON_MAPPER: {
  83       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, InputEpsilonMapper<Arc>()));
  84       args->retval = new FstClass(*ofst);
  85       return;
  86     }
  87     case INVERT_MAPPER: {
  88       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, InvertWeightMapper<Arc>()));
  89       args->retval = new FstClass(*ofst);
  90       return;
  91     }
  92     case OUTPUT_EPSILON_MAPPER: {
  93       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, OutputEpsilonMapper<Arc>()));
  94       args->retval = new FstClass(*ofst);
  95       return;
  96     }
  97     case PLUS_MAPPER: {
  98       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, PlusMapper<Arc>(weight)));
  99       args->retval = new FstClass(*ofst);
 100       return;
 101     }
 102     case QUANTIZE_MAPPER: {
 103       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, QuantizeMapper<Arc>(
 104           std::get<2>(args->args))));
 105       args->retval = new FstClass(*ofst);
 106       return;
 107     }
 108     case RMWEIGHT_MAPPER: {
 109       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, RmWeightMapper<Arc>()));
 110       args->retval = new FstClass(*ofst);
 111       return;
 112     }
 113     case SUPERFINAL_MAPPER: {
 114       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, SuperFinalMapper<Arc>()));
 115       args->retval = new FstClass(*ofst);
 116       return;
 117     }
 118     case TIMES_MAPPER: {
 119       std::unique_ptr<Fst<Arc>> ofst(ArcMap(ifst, TimesMapper<Arc>(weight)));
 120       args->retval = new FstClass(*ofst);
 121       return;
 122     }
 123     case TO_LOG_MAPPER: {
 124       std::unique_ptr<Fst<LogArc>> ofst(ArcMap(ifst,
 125           WeightConvertMapper<Arc, LogArc>()));
 126       args->retval = new FstClass(*ofst);
 127       return;
 128     }
 129     case TO_LOG64_MAPPER: {
 130       std::unique_ptr<Fst<Log64Arc>> ofst(ArcMap(ifst,
 131           WeightConvertMapper<Arc, Log64Arc>()));
 132       args->retval = new FstClass(*ofst);
 133       return;
 134     }
 135     case TO_STD_MAPPER: {
 136       std::unique_ptr<Fst<StdArc>> ofst(ArcMap(ifst,
 137           WeightConvertMapper<Arc, StdArc>()));
 138       args->retval = new FstClass(*ofst);
 139       return;
 140     }
 141   }
 142 }
 143
 144 FstClass *Map(const FstClass &ifst, MapType map_type, float delta,
 145               const WeightClass &weight);
 146
 147 }  // namespace script
 148 }  // namespace fst
 149
 150 #endif  // FST_SCRIPT_MAP_H_