1// register.h
2
3// Licensed under the Apache License, Version 2.0 (the "License");
4// you may not use this file except in compliance with the License.
5// You may obtain a copy of the License at
6//
7//     http://www.apache.org/licenses/LICENSE-2.0
8//
9// Unless required by applicable law or agreed to in writing, software
10// distributed under the License is distributed on an "AS IS" BASIS,
11// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12// See the License for the specific language governing permissions and
13// limitations under the License.
14//
15// Copyright 2005-2010 Google, Inc.
16// Author: riley@google.com (Michael Riley), jpr@google.com (Jake Ratkiewicz)
17//
18// \file
19// Classes for registering derived Fsts for generic reading
20//
21
22#ifndef FST_LIB_REGISTER_H__
23#define FST_LIB_REGISTER_H__
24
25#include <string>
26
27
28#include <fst/compat.h>
29#include <iostream>
30#include <fstream>
31#include <sstream>
32#include <fst/util.h>
33#include <fst/generic-register.h>
34
35
36#include <fst/types.h>
37
38namespace fst {
39
40template <class A> class Fst;
41struct FstReadOptions;
42
43// This class represents a single entry in a FstRegister
44template<class A>
45struct FstRegisterEntry {
46  typedef Fst<A> *(*Reader)(istream &strm, const FstReadOptions &opts);
47  typedef Fst<A> *(*Converter)(const Fst<A> &fst);
48
49  Reader reader;
50  Converter converter;
51  FstRegisterEntry() : reader(0), converter(0) {}
52  FstRegisterEntry(Reader r, Converter c) : reader(r), converter(c) { }
53};
54
55// This class maintains the correspondence between a string describing
56// an FST type, and its reader and converter.
57template<class A>
58class FstRegister : public GenericRegister<string, FstRegisterEntry<A>,
59                                           FstRegister<A> > {
60 public:
61  typedef typename FstRegisterEntry<A>::Reader Reader;
62  typedef typename FstRegisterEntry<A>::Converter Converter;
63
64  const Reader GetReader(const string &type) const {
65    return this->GetEntry(type).reader;
66  }
67
68  const Converter GetConverter(const string &type) const {
69    return this->GetEntry(type).converter;
70  }
71
72 protected:
73  virtual string ConvertKeyToSoFilename(const string& key) const {
74    string legal_type(key);
75
76    ConvertToLegalCSymbol(&legal_type);
77
78    return legal_type + "-fst.so";
79  }
80};
81
82
83// This class registers an Fst type for generic reading and creating.
84// The Fst type must have a default constructor and a copy constructor
85// from 'Fst<Arc>' for this to work.
86template <class F>
87class FstRegisterer
88  : public GenericRegisterer<FstRegister<typename F::Arc> > {
89 public:
90  typedef typename F::Arc Arc;
91  typedef typename FstRegister<Arc>::Entry Entry;
92  typedef typename FstRegister<Arc>::Reader Reader;
93
94  FstRegisterer() :
95      GenericRegisterer<FstRegister<typename F::Arc> >(
96          F().Type(), BuildEntry()) {  }
97
98 private:
99  Entry BuildEntry() {
100    F *(*reader)(istream &strm,
101                 const FstReadOptions &opts) = &F::Read;
102
103    return Entry(reinterpret_cast<Reader>(reader),
104                 &FstRegisterer<F>::Convert);
105  }
106
107  static Fst<Arc> *Convert(const Fst<Arc> &fst) { return new F(fst); }
108};
109
110
111// Convenience macro to generate static FstRegisterer instance.
112#define REGISTER_FST(F, A) \
113static fst::FstRegisterer< F<A> > F ## _ ## A ## _registerer
114
115
116// Converts an fst to type 'type'.
117template <class A>
118Fst<A> *Convert(const Fst<A> &fst, const string &ftype) {
119  FstRegister<A> *registr = FstRegister<A>::GetRegister();
120  const typename FstRegister<A>::Converter
121      converter = registr->GetConverter(ftype);
122  if (!converter) {
123    string atype = A::Type();
124    LOG(ERROR) << "Fst::Convert: Unknown FST type \"" << ftype
125               << "\" (arc type = \"" << atype << "\")";
126    return 0;
127  }
128  return converter(fst);
129}
130
131}  // namespace fst
132
133#endif  // FST_LIB_REGISTER_H__
134