add implementation for kaldi io (by ymz)

1 files changed, 731 insertions, 0 deletions

diff --git a/kaldi_io/src/tools/openfst/include/fst/vector-fst.h b/kaldi_io/src/tools/openfst/include/fst/vector-fst.h
new file mode 100644
index 0000000..8b80876
--- /dev/null
+++ b/kaldi_io/src/tools/openfst/include/fst/vector-fst.h
@@ -0,0 +1,731 @@
+// vector-fst.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
+// Simple concrete, mutable FST whose states and arcs are stored in STL
+// vectors.
+
+#ifndef FST_LIB_VECTOR_FST_H__
+#define FST_LIB_VECTOR_FST_H__
+
+#include <string>
+#include <vector>
+using std::vector;
+
+#include <fst/mutable-fst.h>
+#include <fst/test-properties.h>
+
+
+namespace fst {
+
+template <class A> class VectorFst;
+template <class F, class G> void Cast(const F &, G *);
+
+
+// States and arcs implemented by STL vectors, templated on the
+// State definition. This does not manage the Fst properties.
+template <class State>
+class VectorFstBaseImpl : public FstImpl<typename State::Arc> {
+ public:
+  typedef typename State::Arc Arc;
+  typedef typename Arc::Weight Weight;
+  typedef typename Arc::StateId StateId;
+
+  VectorFstBaseImpl() : start_(kNoStateId) {}
+
+  ~VectorFstBaseImpl() {
+    for (StateId s = 0; s < states_.size(); ++s)
+      delete states_[s];
+  }
+
+  StateId Start() const { return start_; }
+
+  Weight Final(StateId s) const { return states_[s]->final; }
+
+  StateId NumStates() const { return states_.size(); }
+
+  size_t NumArcs(StateId s) const { return states_[s]->arcs.size(); }
+
+  void SetStart(StateId s) { start_ = s; }
+
+  void SetFinal(StateId s, Weight w) { states_[s]->final = w; }
+
+  StateId AddState() {
+    states_.push_back(new State);
+    return states_.size() - 1;
+  }
+
+  StateId AddState(State *state) {
+    states_.push_back(state);
+    return states_.size() - 1;
+  }
+
+  void AddArc(StateId s, const Arc &arc) {
+    states_[s]->arcs.push_back(arc);
+  }
+
+  void DeleteStates(const vector<StateId>& dstates) {
+    vector<StateId> newid(states_.size(), 0);
+    for (size_t i = 0; i < dstates.size(); ++i)
+      newid[dstates[i]] = kNoStateId;
+    StateId nstates = 0;
+    for (StateId s = 0; s < states_.size(); ++s) {
+      if (newid[s] != kNoStateId) {
+        newid[s] = nstates;
+        if (s != nstates)
+          states_[nstates] = states_[s];
+        ++nstates;
+      } else {
+        delete states_[s];
+      }
+    }
+    states_.resize(nstates);
+    for (StateId s = 0; s < states_.size(); ++s) {
+      vector<Arc> &arcs = states_[s]->arcs;
+      size_t narcs = 0;
+      for (size_t i = 0; i < arcs.size(); ++i) {
+        StateId t = newid[arcs[i].nextstate];
+        if (t != kNoStateId) {
+          arcs[i].nextstate = t;
+          if (i != narcs)
+            arcs[narcs] = arcs[i];
+          ++narcs;
+        } else {
+          if (arcs[i].ilabel == 0)
+            --states_[s]->niepsilons;
+          if (arcs[i].olabel == 0)
+            --states_[s]->noepsilons;
+        }
+      }
+      arcs.resize(narcs);
+    }
+    if (Start() != kNoStateId)
+      SetStart(newid[Start()]);
+  }
+
+  void DeleteStates() {
+    for (StateId s = 0; s < states_.size(); ++s)
+      delete states_[s];
+    states_.clear();
+    SetStart(kNoStateId);
+  }
+
+  void DeleteArcs(StateId s, size_t n) {
+    states_[s]->arcs.resize(states_[s]->arcs.size() - n);
+  }
+
+  void DeleteArcs(StateId s) { states_[s]->arcs.clear(); }
+
+  State *GetState(StateId s) { return states_[s]; }
+
+  const State *GetState(StateId s) const { return states_[s]; }
+
+  void SetState(StateId s, State *state) { states_[s] = state; }
+
+  void ReserveStates(StateId n) { states_.reserve(n); }
+
+  void ReserveArcs(StateId s, size_t n) { states_[s]->arcs.reserve(n); }
+
+  // Provide information needed for generic state iterator
+  void InitStateIterator(StateIteratorData<Arc> *data) const {
+    data->base = 0;
+    data->nstates = states_.size();
+  }
+
+  // Provide information needed for generic arc iterator
+  void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const {
+    data->base = 0;
+    data->narcs = states_[s]->arcs.size();
+    data->arcs = data->narcs > 0 ? &states_[s]->arcs[0] : 0;
+    data->ref_count = 0;
+  }
+
+ private:
+  vector<State *> states_;      // States represenation.
+  StateId start_;               // initial state
+
+  DISALLOW_COPY_AND_ASSIGN(VectorFstBaseImpl);
+};
+
+// Arcs implemented by an STL vector per state.
+template <class A>
+struct VectorState {
+  typedef A Arc;
+  typedef typename A::Weight Weight;
+  typedef typename A::StateId StateId;
+
+  VectorState() : final(Weight::Zero()), niepsilons(0), noepsilons(0) {}
+
+  Weight final;              // Final weight
+  vector<A> arcs;            // Arcs represenation
+  size_t niepsilons;         // # of input epsilons
+  size_t noepsilons;         // # of output epsilons
+};
+
+// This is a VectorFstBaseImpl container that holds VectorState's.  It
+// manages Fst properties and the # of input and output epsilons.
+template <class A>
+class VectorFstImpl : public VectorFstBaseImpl< VectorState<A> > {
+ public:
+  using FstImpl<A>::SetInputSymbols;
+  using FstImpl<A>::SetOutputSymbols;
+  using FstImpl<A>::SetType;
+  using FstImpl<A>::SetProperties;
+  using FstImpl<A>::Properties;
+
+  using VectorFstBaseImpl<VectorState<A> >::Start;
+  using VectorFstBaseImpl<VectorState<A> >::NumStates;
+  using VectorFstBaseImpl<VectorState<A> >::GetState;
+  using VectorFstBaseImpl<VectorState<A> >::ReserveArcs;
+
+  friend class MutableArcIterator< VectorFst<A> >;
+
+  typedef VectorFstBaseImpl< VectorState<A> > BaseImpl;
+  typedef typename A::Weight Weight;
+  typedef typename A::StateId StateId;
+
+  VectorFstImpl() {
+    SetType("vector");
+    SetProperties(kNullProperties | kStaticProperties);
+  }
+  explicit VectorFstImpl(const Fst<A> &fst);
+
+  static VectorFstImpl<A> *Read(istream &strm, const FstReadOptions &opts);
+
+  size_t NumInputEpsilons(StateId s) const { return GetState(s)->niepsilons; }
+
+  size_t NumOutputEpsilons(StateId s) const { return GetState(s)->noepsilons; }
+
+  void SetStart(StateId s) {
+    BaseImpl::SetStart(s);
+    SetProperties(SetStartProperties(Properties()));
+  }
+
+  void SetFinal(StateId s, Weight w) {
+    Weight ow = BaseImpl::Final(s);
+    BaseImpl::SetFinal(s, w);
+    SetProperties(SetFinalProperties(Properties(), ow, w));
+  }
+
+  StateId AddState() {
+    StateId s = BaseImpl::AddState();
+    SetProperties(AddStateProperties(Properties()));
+    return s;
+  }
+
+  void AddArc(StateId s, const A &arc) {
+    VectorState<A> *state = GetState(s);
+    if (arc.ilabel == 0) {
+      ++state->niepsilons;
+    }
+    if (arc.olabel == 0) {
+      ++state->noepsilons;
+    }
+
+    const A *parc = state->arcs.empty() ? 0 : &(state->arcs.back());
+    SetProperties(AddArcProperties(Properties(), s, arc, parc));
+
+    BaseImpl::AddArc(s, arc);
+  }
+
+  void DeleteStates(const vector<StateId> &dstates) {
+    BaseImpl::DeleteStates(dstates);
+    SetProperties(DeleteStatesProperties(Properties()));
+  }
+
+  void DeleteStates() {
+    BaseImpl::DeleteStates();
+    SetProperties(DeleteAllStatesProperties(Properties(),
+                                            kStaticProperties));
+  }
+
+  void DeleteArcs(StateId s, size_t n) {
+    const vector<A> &arcs = GetState(s)->arcs;
+    for (size_t i = 0; i < n; ++i) {
+      size_t j = arcs.size() - i - 1;
+      if (arcs[j].ilabel == 0)
+        --GetState(s)->niepsilons;
+      if (arcs[j].olabel == 0)
+        --GetState(s)->noepsilons;
+    }
+    BaseImpl::DeleteArcs(s, n);
+    SetProperties(DeleteArcsProperties(Properties()));
+  }
+
+  void DeleteArcs(StateId s) {
+    GetState(s)->niepsilons = 0;
+    GetState(s)->noepsilons = 0;
+    BaseImpl::DeleteArcs(s);
+    SetProperties(DeleteArcsProperties(Properties()));
+  }
+
+  // Properties always true of this Fst class
+  static const uint64 kStaticProperties = kExpanded | kMutable;
+
+ private:
+  // Current file format version
+  static const int kFileVersion = 2;
+  // Minimum file format version supported
+  static const int kMinFileVersion = 1;
+
+  DISALLOW_COPY_AND_ASSIGN(VectorFstImpl);
+};
+
+template <class A> const uint64 VectorFstImpl<A>::kStaticProperties;
+template <class A> const int VectorFstImpl<A>::kFileVersion;
+template <class A> const int VectorFstImpl<A>::kMinFileVersion;
+
+
+template <class A>
+VectorFstImpl<A>::VectorFstImpl(const Fst<A> &fst) {
+  SetType("vector");
+  SetInputSymbols(fst.InputSymbols());
+  SetOutputSymbols(fst.OutputSymbols());
+  BaseImpl::SetStart(fst.Start());
+  if (fst.Properties(kExpanded, false))
+    BaseImpl::ReserveStates(CountStates(fst));
+
+  for (StateIterator< Fst<A> > siter(fst);
+       !siter.Done();
+       siter.Next()) {
+    StateId s = siter.Value();
+    BaseImpl::AddState();
+    BaseImpl::SetFinal(s, fst.Final(s));
+    ReserveArcs(s, fst.NumArcs(s));
+    for (ArcIterator< Fst<A> > aiter(fst, s);
+         !aiter.Done();
+         aiter.Next()) {
+      const A &arc = aiter.Value();
+      BaseImpl::AddArc(s, arc);
+      if (arc.ilabel == 0)
+        ++GetState(s)->niepsilons;
+      if (arc.olabel == 0)
+        ++GetState(s)->noepsilons;
+    }
+  }
+  SetProperties(fst.Properties(kCopyProperties, false) | kStaticProperties);
+}
+
+template <class A>
+VectorFstImpl<A> *VectorFstImpl<A>::Read(istream &strm,
+                                         const FstReadOptions &opts) {
+  VectorFstImpl<A> *impl = new VectorFstImpl;
+  FstHeader hdr;
+  if (!impl->ReadHeader(strm, opts, kMinFileVersion, &hdr)) {
+    delete impl;
+    return 0;
+  }
+  impl->BaseImpl::SetStart(hdr.Start());
+  if (hdr.NumStates() != kNoStateId) {
+    impl->ReserveStates(hdr.NumStates());
+  }
+
+  StateId s = 0;
+  for (;hdr.NumStates() == kNoStateId || s < hdr.NumStates(); ++s) {
+    typename A::Weight final;
+    if (!final.Read(strm)) break;
+    impl->BaseImpl::AddState();
+    VectorState<A> *state = impl->GetState(s);
+    state->final = final;
+    int64 narcs;
+    ReadType(strm, &narcs);
+    if (!strm) {
+      LOG(ERROR) << "VectorFst::Read: read failed: " << opts.source;
+      delete impl;
+      return 0;
+    }
+    impl->ReserveArcs(s, narcs);
+    for (size_t j = 0; j < narcs; ++j) {
+      A arc;
+      ReadType(strm, &arc.ilabel);
+      ReadType(strm, &arc.olabel);
+      arc.weight.Read(strm);
+       ReadType(strm, &arc.nextstate);
+       if (!strm) {
+        LOG(ERROR) << "VectorFst::Read: read failed: " << opts.source;
+        delete impl;
+        return 0;
+      }
+      impl->BaseImpl::AddArc(s, arc);
+      if (arc.ilabel == 0)
+        ++state->niepsilons;
+      if (arc.olabel == 0)
+        ++state->noepsilons;
+    }
+  }
+  if (hdr.NumStates() != kNoStateId && s != hdr.NumStates()) {
+    LOG(ERROR) << "VectorFst::Read: unexpected end of file: " << opts.source;
+    delete impl;
+    return 0;
+  }
+  return impl;
+}
+
+// Converts a string into a weight.
+template <class W> class WeightFromString {
+ public:
+  W operator()(const string &s);
+};
+
+// Generic case fails.
+template <class W> inline
+W WeightFromString<W>::operator()(const string &s) {
+  FSTERROR() << "VectorFst::Read: Obsolete file format";
+  return W::NoWeight();
+}
+
+// TropicalWeight version.
+template <> inline
+TropicalWeight WeightFromString<TropicalWeight>::operator()(const string &s) {
+  float f;
+  memcpy(&f, s.data(), sizeof(f));
+  return TropicalWeight(f);
+}
+
+// LogWeight version.
+template <> inline
+LogWeight WeightFromString<LogWeight>::operator()(const string &s) {
+  float f;
+  memcpy(&f, s.data(), sizeof(f));
+  return LogWeight(f);
+}
+
+// Simple concrete, mutable FST. This class attaches interface to
+// implementation and handles reference counting, delegating most
+// methods to ImplToMutableFst. Supports additional operations:
+// ReserveStates and ReserveArcs (cf. STL vectors).
+template <class A>
+class VectorFst : public ImplToMutableFst< VectorFstImpl<A> > {
+ public:
+  friend class StateIterator< VectorFst<A> >;
+  friend class ArcIterator< VectorFst<A> >;
+  friend class MutableArcIterator< VectorFst<A> >;
+  template <class F, class G> friend void Cast(const F &, G *);
+
+  typedef A Arc;
+  typedef typename A::StateId StateId;
+  typedef VectorFstImpl<A> Impl;
+
+  VectorFst() : ImplToMutableFst<Impl>(new Impl) {}
+
+  explicit VectorFst(const Fst<A> &fst)
+      : ImplToMutableFst<Impl>(new Impl(fst)) {}
+
+  VectorFst(const VectorFst<A> &fst) : ImplToMutableFst<Impl>(fst) {}
+
+  // Get a copy of this VectorFst. See Fst<>::Copy() for further doc.
+  virtual VectorFst<A> *Copy(bool safe = false) const {
+    return new VectorFst<A>(*this);
+  }
+
+  VectorFst<A> &operator=(const VectorFst<A> &fst) {
+    SetImpl(fst.GetImpl(), false);
+    return *this;
+  }
+
+  virtual VectorFst<A> &operator=(const Fst<A> &fst) {
+    if (this != &fst) SetImpl(new Impl(fst));
+    return *this;
+  }
+
+  // Read a VectorFst from an input stream; return NULL on error
+  static VectorFst<A> *Read(istream &strm, const FstReadOptions &opts) {
+    Impl* impl = Impl::Read(strm, opts);
+    return impl ? new VectorFst<A>(impl) : 0;
+  }
+
+  // Read a VectorFst from a file; return NULL on error
+  // Empty filename reads from standard input
+  static VectorFst<A> *Read(const string &filename) {
+    Impl* impl = ImplToExpandedFst<Impl, MutableFst<A> >::Read(filename);
+    return impl ? new VectorFst<A>(impl) : 0;
+  }
+
+  virtual bool Write(ostream &strm, const FstWriteOptions &opts) const {
+    return WriteFst(*this, strm, opts);
+  }
+
+  virtual bool Write(const string &filename) const {
+    return Fst<A>::WriteFile(filename);
+  }
+
+  template <class F>
+  static bool WriteFst(const F &fst, ostream &strm,
+                       const FstWriteOptions &opts);
+
+  void ReserveStates(StateId n) {
+    MutateCheck();
+    GetImpl()->ReserveStates(n);
+  }
+
+  void ReserveArcs(StateId s, size_t n) {
+    MutateCheck();
+    GetImpl()->ReserveArcs(s, n);
+  }
+
+  virtual void InitStateIterator(StateIteratorData<Arc> *data) const {
+    GetImpl()->InitStateIterator(data);
+  }
+
+  virtual void InitArcIterator(StateId s, ArcIteratorData<Arc> *data) const {
+    GetImpl()->InitArcIterator(s, data);
+  }
+
+  virtual inline
+  void InitMutableArcIterator(StateId s, MutableArcIteratorData<A> *);
+
+ private:
+  explicit VectorFst(Impl *impl) : ImplToMutableFst<Impl>(impl) {}
+
+  // Makes visible to friends.
+  Impl *GetImpl() const { return ImplToFst< Impl, MutableFst<A> >::GetImpl(); }
+
+  void SetImpl(Impl *impl, bool own_impl = true) {
+    ImplToFst< Impl, MutableFst<A> >::SetImpl(impl, own_impl);
+  }
+
+  void MutateCheck() { return ImplToMutableFst<Impl>::MutateCheck(); }
+};
+
+// Specialization for VectorFst; see generic version in fst.h
+// for sample usage (but use the VectorFst type!). This version
+// should inline.
+template <class A>
+class StateIterator< VectorFst<A> > {
+ public:
+  typedef typename A::StateId StateId;
+
+  explicit StateIterator(const VectorFst<A> &fst)
+      : nstates_(fst.GetImpl()->NumStates()), s_(0) {}
+
+  bool Done() const { return s_ >= nstates_; }
+
+  StateId Value() const { return s_; }
+
+  void Next() { ++s_; }
+
+  void Reset() { s_ = 0; }
+
+ private:
+  StateId nstates_;
+  StateId s_;
+
+  DISALLOW_COPY_AND_ASSIGN(StateIterator);
+};
+
+// Writes Fst to file, will call CountStates so may involve two passes if
+// called from an Fst that is not derived from Expanded.
+template <class A>
+template <class F>
+bool VectorFst<A>::WriteFst(const F &fst, ostream &strm,
+                            const FstWriteOptions &opts) {
+  static const int kFileVersion = 2;
+  bool update_header = true;
+  FstHeader hdr;
+  hdr.SetStart(fst.Start());
+  hdr.SetNumStates(kNoStateId);
+  size_t start_offset = 0;
+  if (fst.Properties(kExpanded, false) || (start_offset = strm.tellp()) != -1) {
+    hdr.SetNumStates(CountStates(fst));
+    update_header = false;
+  }
+  uint64 properties = fst.Properties(kCopyProperties, false) |
+      VectorFstImpl<A>::kStaticProperties;
+  FstImpl<A>::WriteFstHeader(fst, strm, opts, kFileVersion, "vector",
+                             properties, &hdr);
+  StateId num_states = 0;
+  for (StateIterator<F> siter(fst); !siter.Done(); siter.Next()) {
+    typename A::StateId s = siter.Value();
+    fst.Final(s).Write(strm);
+    int64 narcs = fst.NumArcs(s);
+    WriteType(strm, narcs);
+    for (ArcIterator<F> aiter(fst, s); !aiter.Done(); aiter.Next()) {
+      const A &arc = aiter.Value();
+      WriteType(strm, arc.ilabel);
+      WriteType(strm, arc.olabel);
+      arc.weight.Write(strm);
+      WriteType(strm, arc.nextstate);
+    }
+    num_states++;
+  }
+  strm.flush();
+  if (!strm) {
+    LOG(ERROR) << "VectorFst::Write: write failed: " << opts.source;
+    return false;
+  }
+  if (update_header) {
+    hdr.SetNumStates(num_states);
+    return FstImpl<A>::UpdateFstHeader(fst, strm, opts, kFileVersion, "vector",
+                                       properties, &hdr, start_offset);
+  } else {
+    if (num_states != hdr.NumStates()) {
+      LOG(ERROR) << "Inconsistent number of states observed during write";
+      return false;
+    }
+  }
+  return true;
+}
+
+// Specialization for VectorFst; see generic version in fst.h
+// for sample usage (but use the VectorFst type!). This version
+// should inline.
+template <class A>
+class ArcIterator< VectorFst<A> > {
+ public:
+  typedef typename A::StateId StateId;
+
+  ArcIterator(const VectorFst<A> &fst, StateId s)
+      : arcs_(fst.GetImpl()->GetState(s)->arcs), i_(0) {}
+
+  bool Done() const { return i_ >= arcs_.size(); }
+
+  const A& Value() const { return arcs_[i_]; }
+
+  void Next() { ++i_; }
+
+  void Reset() { i_ = 0; }
+
+  void Seek(size_t a) { i_ = a; }
+
+  size_t Position() const { return i_; }
+
+  uint32 Flags() const {
+    return kArcValueFlags;
+  }
+
+  void SetFlags(uint32 f, uint32 m) {}
+
+ private:
+  const vector<A>& arcs_;
+  size_t i_;
+
+  DISALLOW_COPY_AND_ASSIGN(ArcIterator);
+};
+
+// Specialization for VectorFst; see generic version in fst.h
+// for sample usage (but use the VectorFst type!). This version
+// should inline.
+template <class A>
+class MutableArcIterator< VectorFst<A> >
+  : public MutableArcIteratorBase<A> {
+ public:
+  typedef typename A::StateId StateId;
+  typedef typename A::Weight Weight;
+
+  MutableArcIterator(VectorFst<A> *fst, StateId s) : i_(0) {
+    fst->MutateCheck();
+    state_ = fst->GetImpl()->GetState(s);
+    properties_ = &fst->GetImpl()->properties_;
+  }
+
+  bool Done() const { return i_ >= state_->arcs.size(); }
+
+  const A& Value() const { return state_->arcs[i_]; }
+
+  void Next() { ++i_; }
+
+  size_t Position() const { return i_; }
+
+  void Reset() { i_ = 0; }
+
+  void Seek(size_t a) { i_ = a; }
+
+  void SetValue(const A &arc) {
+    A& oarc = state_->arcs[i_];
+    if (oarc.ilabel != oarc.olabel)
+      *properties_ &= ~kNotAcceptor;
+    if (oarc.ilabel == 0) {
+      --state_->niepsilons;
+      *properties_ &= ~kIEpsilons;
+      if (oarc.olabel == 0)
+        *properties_ &= ~kEpsilons;
+    }
+    if (oarc.olabel == 0) {
+      --state_->noepsilons;
+      *properties_ &= ~kOEpsilons;
+    }
+    if (oarc.weight != Weight::Zero() && oarc.weight != Weight::One())
+      *properties_ &= ~kWeighted;
+    oarc = arc;
+    if (arc.ilabel != arc.olabel) {
+      *properties_ |= kNotAcceptor;
+      *properties_ &= ~kAcceptor;
+    }
+    if (arc.ilabel == 0) {
+      ++state_->niepsilons;
+      *properties_ |= kIEpsilons;
+      *properties_ &= ~kNoIEpsilons;
+      if (arc.olabel == 0) {
+        *properties_ |= kEpsilons;
+        *properties_ &= ~kNoEpsilons;
+      }
+    }
+    if (arc.olabel == 0) {
+      ++state_->noepsilons;
+      *properties_ |= kOEpsilons;
+      *properties_ &= ~kNoOEpsilons;
+    }
+    if (arc.weight != Weight::Zero() && arc.weight != Weight::One()) {
+      *properties_ |= kWeighted;
+      *properties_ &= ~kUnweighted;
+    }
+    *properties_ &= kSetArcProperties | kAcceptor | kNotAcceptor |
+        kEpsilons | kNoEpsilons | kIEpsilons | kNoIEpsilons |
+        kOEpsilons | kNoOEpsilons | kWeighted | kUnweighted;
+  }
+
+  uint32 Flags() const {
+    return kArcValueFlags;
+  }
+
+  void SetFlags(uint32 f, uint32 m) {}
+
+
+ private:
+  // This allows base-class virtual access to non-virtual derived-
+  // class members of the same name. It makes the derived class more
+  // efficient to use but unsafe to further derive.
+  virtual bool Done_() const { return Done(); }
+  virtual const A& Value_() const { return Value(); }
+  virtual void Next_() { Next(); }
+  virtual size_t Position_() const { return Position(); }
+  virtual void Reset_() { Reset(); }
+  virtual void Seek_(size_t a) { Seek(a); }
+  virtual void SetValue_(const A &a) { SetValue(a); }
+  uint32 Flags_() const { return Flags(); }
+  void SetFlags_(uint32 f, uint32 m) { SetFlags(f, m); }
+
+  struct VectorState<A> *state_;
+  uint64 *properties_;
+  size_t i_;
+
+  DISALLOW_COPY_AND_ASSIGN(MutableArcIterator);
+};
+
+// Provide information needed for the generic mutable arc iterator
+template <class A> inline
+void VectorFst<A>::InitMutableArcIterator(
+    StateId s, MutableArcIteratorData<A> *data) {
+  data->base = new MutableArcIterator< VectorFst<A> >(this, s);
+}
+
+// A useful alias when using StdArc.
+typedef VectorFst<StdArc> StdVectorFst;
+
+}  // namespace fst
+
+#endif  // FST_LIB_VECTOR_FST_H__