Merge pull request #2 from yimmon/master

remove needless files

1 files changed, 0 insertions, 481 deletions

diff --git a/kaldi_io/src/tools/openfst/include/fst/state-table.h b/kaldi_io/src/tools/openfst/include/fst/state-table.h
deleted file mode 100644
index d8107a1..0000000
--- a/kaldi_io/src/tools/openfst/include/fst/state-table.h
+++ /dev/null
@@ -1,481 +0,0 @@
-// state-table.h
-
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Copyright 2005-2010 Google, Inc.
-// Author: [email protected] (Michael Riley)
-//
-// \file
-// Classes for representing the mapping between state tuples and state Ids.
-
-#ifndef FST_LIB_STATE_TABLE_H__
-#define FST_LIB_STATE_TABLE_H__
-
-#include <deque>
-using std::deque;
-#include <vector>
-using std::vector;
-
-#include <fst/bi-table.h>
-#include <fst/expanded-fst.h>
-
-
-namespace fst {
-
-// STATE TABLES - these determine the bijective mapping between state
-// tuples (e.g. in composition triples of two FST states and a
-// composition filter state) and their corresponding state IDs.
-// They are classes, templated on state tuples, of the form:
-//
-// template <class T>
-// class StateTable {
-//  public:
-//   typedef typename T StateTuple;
-//
-//   // Required constructors.
-//   StateTable();
-//
-//   // Lookup state ID by tuple. If it doesn't exist, then add it.
-//   StateId FindState(const StateTuple &);
-//   // Lookup state tuple by state ID.
-//   const StateTuple<StateId> &Tuple(StateId) const;
-//   // # of stored tuples.
-//   StateId Size() const;
-// };
-//
-// A state tuple has the form:
-//
-// template <class S>
-// struct StateTuple {
-//   typedef typename S StateId;
-//
-//   // Required constructors.
-//   StateTuple();
-//   StateTuple(const StateTuple &);
-// };
-
-
-// An implementation using a hash map for the tuple to state ID mapping.
-// The state tuple T must have == defined. H is the hash function.
-template <class T, class H>
-class HashStateTable : public HashBiTable<typename T::StateId, T, H> {
- public:
-  typedef T StateTuple;
-  typedef typename StateTuple::StateId StateId;
-  using HashBiTable<StateId, T, H>::FindId;
-  using HashBiTable<StateId, T, H>::FindEntry;
-  using HashBiTable<StateId, T, H>::Size;
-
-  HashStateTable() : HashBiTable<StateId, T, H>() {}
-
-  // Reserves space for table_size elements.
-  explicit HashStateTable(size_t table_size)
-      : HashBiTable<StateId, T, H>(table_size) {}
-
-  StateId FindState(const StateTuple &tuple) { return FindId(tuple); }
-  const StateTuple &Tuple(StateId s) const { return FindEntry(s); }
-};
-
-
-// An implementation using a hash map for the tuple to state ID mapping.
-// The state tuple T must have == defined. H is the hash function.
-template <class T, class H>
-class CompactHashStateTable
-    : public CompactHashBiTable<typename T::StateId, T, H> {
- public:
-  typedef T StateTuple;
-  typedef typename StateTuple::StateId StateId;
-  using CompactHashBiTable<StateId, T, H>::FindId;
-  using CompactHashBiTable<StateId, T, H>::FindEntry;
-  using CompactHashBiTable<StateId, T, H>::Size;
-
-  CompactHashStateTable() : CompactHashBiTable<StateId, T, H>() {}
-
-  // Reserves space for 'table_size' elements.
-  explicit CompactHashStateTable(size_t table_size)
-      : CompactHashBiTable<StateId, T, H>(table_size) {}
-
-  StateId FindState(const StateTuple &tuple) { return FindId(tuple); }
-  const StateTuple &Tuple(StateId s) const { return FindEntry(s); }
-};
-
-// An implementation using a vector for the tuple to state mapping.
-// It is passed a function object FP that should fingerprint tuples
-// uniquely to an integer that can used as a vector index. Normally,
-// VectorStateTable constructs the FP object.  The user can instead
-// pass in this object; in that case, VectorStateTable takes its
-// ownership.
-template <class T, class FP>
-class VectorStateTable
-    : public VectorBiTable<typename T::StateId, T, FP> {
- public:
-  typedef T StateTuple;
-  typedef typename StateTuple::StateId StateId;
-  using VectorBiTable<StateId, T, FP>::FindId;
-  using VectorBiTable<StateId, T, FP>::FindEntry;
-  using VectorBiTable<StateId, T, FP>::Size;
-  using VectorBiTable<StateId, T, FP>::Fingerprint;
-
-  // Reserves space for 'table_size' elements.
-  explicit VectorStateTable(FP *fp = 0, size_t table_size = 0)
-      : VectorBiTable<StateId, T, FP>(fp, table_size) {}
-
-  StateId FindState(const StateTuple &tuple) { return FindId(tuple); }
-  const StateTuple &Tuple(StateId s) const { return FindEntry(s); }
-};
-
-
-// An implementation using a vector and a compact hash table. The
-// selecting functor S returns true for tuples to be hashed in the
-// vector.  The fingerprinting functor FP returns a unique fingerprint
-// for each tuple to be hashed in the vector (these need to be
-// suitable for indexing in a vector).  The hash functor H is used when
-// hashing tuple into the compact hash table.
-template <class T, class S, class FP, class H>
-class VectorHashStateTable
-    : public VectorHashBiTable<typename T::StateId, T, S, FP, H> {
- public:
-  typedef T StateTuple;
-  typedef typename StateTuple::StateId StateId;
-  using VectorHashBiTable<StateId, T, S, FP, H>::FindId;
-  using VectorHashBiTable<StateId, T, S, FP, H>::FindEntry;
-  using VectorHashBiTable<StateId, T, S, FP, H>::Size;
-  using VectorHashBiTable<StateId, T, S, FP, H>::Selector;
-  using VectorHashBiTable<StateId, T, S, FP, H>::Fingerprint;
-  using VectorHashBiTable<StateId, T, S, FP, H>::Hash;
-
-  VectorHashStateTable(S *s, FP *fp, H *h,
-                       size_t vector_size = 0,
-                       size_t tuple_size = 0)
-      : VectorHashBiTable<StateId, T, S, FP, H>(
-          s, fp, h, vector_size, tuple_size) {}
-
-  StateId FindState(const StateTuple &tuple) { return FindId(tuple); }
-  const StateTuple &Tuple(StateId s) const { return FindEntry(s); }
-};
-
-
-// An implementation using a hash map for the tuple to state ID
-// mapping. This version permits erasing of states.  The state tuple T
-// must have == defined and its default constructor must produce a
-// tuple that will never be seen. F is the hash function.
-template <class T, class F>
-class ErasableStateTable : public ErasableBiTable<typename T::StateId, T, F> {
- public:
-  typedef T StateTuple;
-  typedef typename StateTuple::StateId StateId;
-  using ErasableBiTable<StateId, T, F>::FindId;
-  using ErasableBiTable<StateId, T, F>::FindEntry;
-  using ErasableBiTable<StateId, T, F>::Size;
-  using ErasableBiTable<StateId, T, F>::Erase;
-
-  ErasableStateTable() : ErasableBiTable<StateId, T, F>() {}
-  StateId FindState(const StateTuple &tuple) { return FindId(tuple); }
-  const StateTuple &Tuple(StateId s) const { return FindEntry(s); }
-};
-
-//
-// COMPOSITION STATE TUPLES AND TABLES
-//
-// The composition state table has the form:
-//
-// template <class A, class F>
-// class ComposeStateTable {
-//  public:
-//   typedef A Arc;
-//   typedef F FilterState;
-//   typedef typename A::StateId StateId;
-//   typedef ComposeStateTuple<StateId> StateTuple;
-//
-//   // Required constructors. Copy constructor does not copy state.
-//   ComposeStateTable(const Fst<Arc> &fst1, const Fst<Arc> &fst2);
-//   ComposeStateTable(const ComposeStateTable<A, F> &table);
-//   // Lookup state ID by tuple. If it doesn't exist, then add it.
-//   StateId FindState(const StateTuple &);
-//   // Lookup state tuple by state ID.
-//   const StateTuple<StateId> &Tuple(StateId) const;
-//   // # of stored tuples.
-//   StateId Size() const;
-//   // Return true if error encountered
-//   bool Error() const;
-// };
-
-// Represents the composition state.
-template <typename S, typename F>
-struct ComposeStateTuple {
-  typedef S StateId;
-  typedef F FilterState;
-
-  ComposeStateTuple()
-      : state_id1(kNoStateId), state_id2(kNoStateId),
-        filter_state(FilterState::NoState()) {}
-
-  ComposeStateTuple(StateId s1, StateId s2, const FilterState &f)
-      : state_id1(s1), state_id2(s2), filter_state(f) {}
-
-  StateId state_id1;         // State Id on fst1
-  StateId state_id2;         // State Id on fst2
-  FilterState filter_state;  // State of composition filter
-};
-
-// Equality of composition state tuples.
-template <typename S, typename F>
-inline bool operator==(const ComposeStateTuple<S, F>& x,
-                       const ComposeStateTuple<S, F>& y) {
-  if (&x == &y)
-    return true;
-  return x.state_id1 == y.state_id1 &&
-      x.state_id2 == y.state_id2 &&
-      x.filter_state == y.filter_state;
-}
-
-
-// Hashing of composition state tuples.
-template <typename S, typename F>
-class ComposeHash {
- public:
-  size_t operator()(const ComposeStateTuple<S, F>& t) const {
-    return t.state_id1 + t.state_id2 * kPrime0 +
-        t.filter_state.Hash() * kPrime1;
-  }
- private:
-  static const size_t kPrime0;
-  static const size_t kPrime1;
-};
-
-template <typename S, typename F>
-const size_t ComposeHash<S, F>::kPrime0 = 7853;
-
-template <typename S, typename F>
-const size_t ComposeHash<S, F>::kPrime1 = 7867;
-
-
-// A HashStateTable over composition tuples.
-template <typename A,
-          typename F,
-          typename H =
-          CompactHashStateTable<ComposeStateTuple<typename A::StateId, F>,
-                                ComposeHash<typename A::StateId, F> > >
-class GenericComposeStateTable : public H {
- public:
-  typedef A Arc;
-  typedef typename A::StateId StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<StateId, F> StateTuple;
-
-  GenericComposeStateTable(const Fst<A> &fst1, const Fst<A> &fst2) {}
-
-  // Reserves space for 'table_size' elements.
-  GenericComposeStateTable(const Fst<A> &fst1, const Fst<A> &fst2,
-                           size_t table_size) : H(table_size) {}
-
-  bool Error() const { return false; }
-
- private:
-  void operator=(const GenericComposeStateTable<A, F> &table);  // disallow
-};
-
-
-//  Fingerprint for general composition tuples.
-template  <typename S, typename F>
-class ComposeFingerprint {
- public:
-  typedef S StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<S, F> StateTuple;
-
-  // Required but suboptimal constructor.
-  ComposeFingerprint() : mult1_(8192), mult2_(8192) {
-    LOG(WARNING) << "TupleFingerprint: # of FST states should be provided.";
-  }
-
-  // Constructor is provided the sizes of the input FSTs
-  ComposeFingerprint(StateId nstates1, StateId nstates2)
-      : mult1_(nstates1), mult2_(nstates1 * nstates2) { }
-
-  size_t operator()(const StateTuple &tuple) {
-    return tuple.state_id1 + tuple.state_id2 * mult1_ +
-        tuple.filter_state.Hash() * mult2_;
-  }
-
- private:
-  ssize_t mult1_;
-  ssize_t mult2_;
-};
-
-
-// Useful when the first composition state determines the tuple.
-template  <typename S, typename F>
-class ComposeState1Fingerprint {
- public:
-  typedef S StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<S, F> StateTuple;
-
-  size_t operator()(const StateTuple &tuple) { return tuple.state_id1; }
-};
-
-
-// Useful when the second composition state determines the tuple.
-template  <typename S, typename F>
-class ComposeState2Fingerprint {
- public:
-  typedef S StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<S, F> StateTuple;
-
-  size_t operator()(const StateTuple &tuple) { return tuple.state_id2; }
-};
-
-
-// A VectorStateTable over composition tuples.  This can be used when
-// the product of number of states in FST1 and FST2 (and the
-// composition filter state hash) is manageable. If the FSTs are not
-// expanded Fsts, they will first have their states counted.
-template  <typename A, typename F>
-class ProductComposeStateTable : public
-VectorStateTable<ComposeStateTuple<typename A::StateId, F>,
-                 ComposeFingerprint<typename A::StateId, F> > {
- public:
-  typedef A Arc;
-  typedef typename A::StateId StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<StateId, F> StateTuple;
-  typedef VectorStateTable<StateTuple,
-                           ComposeFingerprint<StateId, F> > StateTable;
-
-  // Reserves space for 'table_size' elements.
-  ProductComposeStateTable(const Fst<A> &fst1, const Fst<A> &fst2,
-                           size_t table_size = 0)
-      : StateTable(new ComposeFingerprint<StateId, F>(CountStates(fst1),
-                                                      CountStates(fst2)),
-                   table_size) {}
-
-  ProductComposeStateTable(const ProductComposeStateTable<A, F> &table)
-      : StateTable(new ComposeFingerprint<StateId, F>(table.Fingerprint())) {}
-
-  bool Error() const { return false; }
-
- private:
-  void operator=(const ProductComposeStateTable<A, F> &table);  // disallow
-};
-
-// A VectorStateTable over composition tuples.  This can be used when
-// FST1 is a string (satisfies kStringProperties) and FST2 is
-// epsilon-free and deterministic. It should be used with a
-// composition filter that creates at most one filter state per tuple
-// under these conditions (e.g. SequenceComposeFilter or
-// MatchComposeFilter).
-template <typename A, typename F>
-class StringDetComposeStateTable : public
-VectorStateTable<ComposeStateTuple<typename A::StateId, F>,
-                 ComposeState1Fingerprint<typename A::StateId, F> > {
- public:
-  typedef A Arc;
-  typedef typename A::StateId StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<StateId, F> StateTuple;
-  typedef VectorStateTable<StateTuple,
-                           ComposeState1Fingerprint<StateId, F> > StateTable;
-
-  StringDetComposeStateTable(const Fst<A> &fst1, const Fst<A> &fst2)
-      : error_(false) {
-    uint64 props1 = kString;
-    uint64 props2 = kIDeterministic | kNoIEpsilons;
-    if (fst1.Properties(props1, true) != props1 ||
-        fst2.Properties(props2, true) != props2) {
-      FSTERROR() << "StringDetComposeStateTable: fst1 not a string or"
-                 << " fst2 not input deterministic and epsilon-free";
-      error_ = true;
-    }
-  }
-
-  StringDetComposeStateTable(const StringDetComposeStateTable<A, F> &table)
-      : StateTable(table), error_(table.error_) {}
-
-  bool Error() const { return error_; }
-
- private:
-  bool error_;
-
-  void operator=(const StringDetComposeStateTable<A, F> &table);  // disallow
-};
-
-
-// A VectorStateTable over composition tuples.  This can be used when
-// FST2 is a string (satisfies kStringProperties) and FST1 is
-// epsilon-free and deterministic. It should be used with a
-// composition filter that creates at most one filter state per tuple
-// under these conditions (e.g. SequenceComposeFilter or
-// MatchComposeFilter).
-template <typename A, typename F>
-class DetStringComposeStateTable : public
-VectorStateTable<ComposeStateTuple<typename A::StateId, F>,
-                 ComposeState2Fingerprint<typename A::StateId, F> > {
- public:
-  typedef A Arc;
-  typedef typename A::StateId StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<StateId, F> StateTuple;
-  typedef VectorStateTable<StateTuple,
-                           ComposeState2Fingerprint<StateId, F> > StateTable;
-
-  DetStringComposeStateTable(const Fst<A> &fst1, const Fst<A> &fst2)
-      :error_(false) {
-    uint64 props1 = kODeterministic | kNoOEpsilons;
-    uint64 props2 = kString;
-    if (fst1.Properties(props1, true) != props1 ||
-        fst2.Properties(props2, true) != props2) {
-      FSTERROR() << "StringDetComposeStateTable: fst2 not a string or"
-                 << " fst1 not output deterministic and epsilon-free";
-      error_ = true;
-    }
-  }
-
-  DetStringComposeStateTable(const DetStringComposeStateTable<A, F> &table)
-      : StateTable(table), error_(table.error_) {}
-
-  bool Error() const { return error_; }
-
- private:
-  bool error_;
-
-  void operator=(const DetStringComposeStateTable<A, F> &table);  // disallow
-};
-
-
-// An ErasableStateTable over composition tuples. The Erase(StateId) method
-// can be called if the user either is sure that composition will never return
-// to that tuple or doesn't care that if it does, it is assigned a new
-// state ID.
-template <typename A, typename F>
-class ErasableComposeStateTable : public
-ErasableStateTable<ComposeStateTuple<typename A::StateId, F>,
-                   ComposeHash<typename A::StateId, F> > {
- public:
-  typedef A Arc;
-  typedef typename A::StateId StateId;
-  typedef F FilterState;
-  typedef ComposeStateTuple<StateId, F> StateTuple;
-
-  ErasableComposeStateTable(const Fst<A> &fst1, const Fst<A> &fst2) {}
-
-  bool Error() const { return false; }
-
- private:
-  void operator=(const ErasableComposeStateTable<A, F> &table);  // disallow
-};
-
-}  // namespace fst
-
-#endif  // FST_LIB_STATE_TABLE_H__