// See www.openfst.org for extensive documentation on this weighted
|
// finite-state transducer library.
|
//
|
// This file defines the registration mechanism for new operations.
|
// These operations are designed to enable scripts to work with FST classes
|
// at a high level.
|
//
|
// If you have a new arc type and want these operations to work with FSTs
|
// with that arc type, see below for the registration steps
|
// you must take.
|
//
|
// These methods are only recommended for use in high-level scripting
|
// applications. Most users should use the lower-level templated versions
|
// corresponding to these.
|
//
|
// If you have a new arc type you'd like these operations to work with,
|
// use the REGISTER_FST_OPERATIONS macro defined in fstscript.h.
|
//
|
// If you have a custom operation you'd like to define, you need four
|
// components. In the following, assume you want to create a new operation
|
// with the signature
|
//
|
// void Foo(const FstClass &ifst, MutableFstClass *ofst);
|
//
|
// You need:
|
//
|
// 1) A way to bundle the args that your new Foo operation will take, as
|
// a single struct. The template structs in arg-packs.h provide a handy
|
// way to do this. In Foo's case, that might look like this:
|
//
|
// using FooArgs = std::pair<const FstClass &, MutableFstClass *>;
|
//
|
// Note: this package of args is going to be passed by non-const pointer.
|
//
|
// 2) A function template that is able to perform Foo, given the args and
|
// arc type. Yours might look like this:
|
//
|
// template<class Arc>
|
// void Foo(FooArgs *args) {
|
// // Pulls out the actual, arc-templated FSTs.
|
// const Fst<Arc> &ifst = std::get<0>(*args).GetFst<Arc>();
|
// MutableFst<Arc> *ofst = std::get<1>(*args)->GetMutableFst<Arc>();
|
// // Actually perform Foo on ifst and ofst.
|
// }
|
//
|
// 3) a client-facing function for your operation. This would look like
|
// the following:
|
//
|
// void Foo(const FstClass &ifst, MutableFstClass *ofst) {
|
// // Check that the arc types of the FSTs match
|
// if (!ArcTypesMatch(ifst, *ofst, "Foo")) return;
|
// // package the args
|
// FooArgs args(ifst, ofst);
|
// // Finally, call the operation
|
// Apply<Operation<FooArgs>>("Foo", ifst->ArcType(), &args);
|
// }
|
//
|
// The Apply<> function template takes care of the link between 2 and 3,
|
// provided you also have:
|
//
|
// 4) A registration for your new operation, on the arc types you care about.
|
// This can be provided easily by the REGISTER_FST_OPERATION macro in
|
// operations.h:
|
//
|
// REGISTER_FST_OPERATION(Foo, StdArc, FooArgs);
|
// REGISTER_FST_OPERATION(Foo, MyArc, FooArgs);
|
// // .. etc
|
//
|
//
|
// That's it! Now when you call Foo(const FstClass &, MutableFstClass *),
|
// it dispatches (in #3) via the Apply<> function to the correct
|
// instantiation of the template function in #2.
|
//
|
|
#ifndef FST_SCRIPT_SCRIPT_IMPL_H_
|
#define FST_SCRIPT_SCRIPT_IMPL_H_
|
|
// This file contains general-purpose templates which are used in the
|
// implementation of the operations.
|
|
#include <string>
|
#include <utility>
|
|
#include <fst/generic-register.h>
|
#include <fst/script/fst-class.h>
|
|
#include <fst/log.h>
|
|
namespace fst {
|
namespace script {
|
|
enum RandArcSelection {
|
UNIFORM_ARC_SELECTOR,
|
LOG_PROB_ARC_SELECTOR,
|
FAST_LOG_PROB_ARC_SELECTOR
|
};
|
|
// A generic register for operations with various kinds of signatures.
|
// Needed since every function signature requires a new registration class.
|
// The std::pair<string, string> is understood to be the operation name and arc
|
// type; subclasses (or typedefs) need only provide the operation signature.
|
|
template <class OperationSignature>
|
class GenericOperationRegister
|
: public GenericRegister<std::pair<string, string>, OperationSignature,
|
GenericOperationRegister<OperationSignature>> {
|
public:
|
void RegisterOperation(const string &operation_name, const string &arc_type,
|
OperationSignature op) {
|
this->SetEntry(std::make_pair(operation_name, arc_type), op);
|
}
|
|
OperationSignature GetOperation(const string &operation_name,
|
const string &arc_type) {
|
return this->GetEntry(std::make_pair(operation_name, arc_type));
|
}
|
|
protected:
|
string ConvertKeyToSoFilename(
|
const std::pair<string, string> &key) const final {
|
// Uses the old-style FST for now.
|
string legal_type(key.second); // The arc type.
|
ConvertToLegalCSymbol(&legal_type);
|
return legal_type + "-arc.so";
|
}
|
};
|
|
// Operation package: everything you need to register a new type of operation.
|
// The ArgPack should be the type that's passed into each wrapped function;
|
// for instance, it might be a struct containing all the args. It's always
|
// passed by pointer, so const members should be used to enforce constness where
|
// it's needed. Return values should be implemented as a member of ArgPack as
|
// well.
|
|
template <class Args>
|
struct Operation {
|
using ArgPack = Args;
|
|
using OpType = void (*)(ArgPack *args);
|
|
// The register (hash) type.
|
using Register = GenericOperationRegister<OpType>;
|
|
// The register-er type
|
using Registerer = GenericRegisterer<Register>;
|
};
|
|
// Macro for registering new types of operations.
|
|
#define REGISTER_FST_OPERATION(Op, Arc, ArgPack) \
|
static fst::script::Operation<ArgPack>::Registerer \
|
arc_dispatched_operation_##ArgPack##Op##Arc##_registerer \
|
(std::make_pair(#Op, Arc::Type()), Op<Arc>)
|
|
// Template function to apply an operation by name.
|
|
template <class OpReg>
|
void Apply(const string &op_name, const string &arc_type,
|
typename OpReg::ArgPack *args) {
|
const auto op = OpReg::Register::GetRegister()->GetOperation(op_name,
|
arc_type);
|
if (!op) {
|
FSTERROR() << "No operation found for " << op_name << " on "
|
<< "arc type " << arc_type;
|
return;
|
}
|
op(args);
|
}
|
|
namespace internal {
|
|
// Helper that logs to ERROR if the arc types of m and n don't match,
|
// assuming that both m and n implement .ArcType(). The op_name argument is
|
// used to construct the error message.
|
template <class M, class N>
|
bool ArcTypesMatch(const M &m, const N &n, const string &op_name) {
|
if (m.ArcType() != n.ArcType()) {
|
FSTERROR() << "Arguments with non-matching arc types passed to "
|
<< op_name << ":\t" << m.ArcType() << " and " << n.ArcType();
|
return false;
|
}
|
return true;
|
}
|
|
// From untyped to typed weights.
|
template <class Weight>
|
void CopyWeights(const std::vector<WeightClass> &weights,
|
std::vector<Weight> *typed_weights) {
|
typed_weights->clear();
|
typed_weights->reserve(weights.size());
|
for (const auto &weight : weights) {
|
typed_weights->push_back(*weight.GetWeight<Weight>());
|
}
|
}
|
|
// From typed to untyped weights.
|
template <class Weight>
|
void CopyWeights(const std::vector<Weight> &typed_weights,
|
std::vector<WeightClass> *weights) {
|
weights->clear();
|
weights->reserve(typed_weights.size());
|
for (const auto &typed_weight : typed_weights) {
|
weights->emplace_back(typed_weight);
|
}
|
}
|
|
} // namespace internal
|
} // namespace script
|
} // namespace fst
|
|
#endif // FST_SCRIPT_SCRIPT_IMPL_H_
|
