fst::pre_determinize_helpers Namespace Reference

Functions
bool	HasBannedPrefixPlusDigits (SymbolTable *symTable, std::string prefix, std::string *bad_sym)
template<class T >
void	CopySetToVector (const std::set< T > s, std::vector< T > *v)
template<class T >
std::vector< T > *	InsertMember (const std::vector< T > m, std::vector< std::vector< T > *> *S)
template<class Arc >
void	Closure (MutableFst< Arc > *fst, std::set< typename Arc::StateId > *S, const std::vector< bool > &pVec)

Function Documentation

Closure()

void fst::pre_determinize_helpers::Closure	(	MutableFst< Arc > *	fst,
		std::set< typename Arc::StateId > *	S,
		const std::vector< bool > &	pVec
	)

Definition at line 291 of file pre-determinize-inl.h.

References CopySetToVector().

Referenced by fst::MakeLoopFstCompare(), and fst::PreDeterminize().

                                                              {
  typedef typename Arc::StateId StateId;
  std::vector<StateId> Q;
  CopySetToVector(*S, &Q);
  while (Q.size() != 0) {
    StateId s = Q.back();
    Q.pop_back();
    for (ArcIterator<MutableFst<Arc> > aiter(*fst, s); ! aiter.Done(); aiter.Next()) {
      const Arc &arc = aiter.Value();
      if (arc.ilabel != 0) break;  // Break from the loop: due to sorting there will be no
      // more transitions with epsilons as input labels.
      if (!pVec[arc.nextstate]) {  // Next state is not problematic -> we can use this transition.
        std::pair< typename std::set<StateId>::iterator, bool > p = S->insert(arc.nextstate);
        if (p.second) {  // True means: was inserted into S (wasn't already there).
          Q.push_back(arc.nextstate);
        }
      }
    }
  }
} // end function Closure.

CopySetToVector()

void fst::pre_determinize_helpers::CopySetToVector	(	const std::set< T >	s,
		std::vector< T > *	v
	)

Definition at line 256 of file pre-determinize-inl.h.

Referenced by Closure(), and fst::PreDeterminize().

                                                                           {
  // adds members of s to v, in sorted order from lowest to highest
  // (because the set was in sorted order).
  assert(v != NULL);
  v->resize(s.size());
  typename std::set<T>::const_iterator siter = s.begin();
  typename std::vector<T>::iterator viter = v->begin();
  for (;  siter != s.end(); ++siter, ++viter) {
    assert(viter != v->end());
    *viter = *siter;
  }
}

HasBannedPrefixPlusDigits()

bool fst::pre_determinize_helpers::HasBannedPrefixPlusDigits ( SymbolTable *  symTable, std::string  prefix, std::string *  bad_sym  )

inline

Definition at line 230 of file pre-determinize-inl.h.

                                                                                                   {
  // returns true if the symbol table contains any string consisting of this
  // (possibly empty) prefix followed by a nonempty sequence of digits (0 to 9).
  // requires symTable to be non-NULL.
  // if bad_sym != NULL, puts the first bad symbol it finds in *bad_sym.
  assert(symTable != NULL);
  const char *prefix_ptr = prefix.c_str();
  size_t prefix_len = strlen(prefix_ptr);  // allowed to be zero but not encouraged.
  for (SymbolTableIterator siter(*symTable); !siter.Done(); siter.Next()) {
    const char *sym = siter.Symbol().c_str();
    if (!strncmp(prefix_ptr, sym, prefix_len)) {  // has prefix.
      if (isdigit(sym[prefix_len])) {  // we don't allow prefix followed by a digit, as a symbol.
        // Has at least one digit.
        size_t pos;
        for (pos = prefix_len;sym[pos] != '\0'; pos++)
          if (!isdigit(sym[pos])) break;
        if (sym[pos] == '\0') {  // All remaining characters were digits.
          if (bad_sym != NULL) *bad_sym = (std::string) sym;
          return true;
        }
      } // else OK because prefix was followed by '\0' or a non-digit.
    }
  }
  return false;  // doesn't have banned symbol.
}

InsertMember()

std::vector<T>* fst::pre_determinize_helpers::InsertMember	(	const std::vector< T >	m,
		std::vector< std::vector< T > *> *	S
	)

Definition at line 271 of file pre-determinize-inl.h.

Referenced by fst::PreDeterminize().

                                                                              {
  assert(m.size() > 0);
  T idx = m[0];
  assert(idx>=(T)0 && idx < (T)S->size());
  if ( (*S)[idx] != NULL) {
    assert( *((*S)[idx]) == m );
    // The vectors should be the same.  Otherwise this is a bug in the algorithm.
    // It could either be a programming error or a deeper conceptual bug.
    return NULL;  // nothing was inserted.
  } else {
    std::vector<T> *ret = (*S)[idx] = new std::vector<T>(m);  // New copy of m.
    return ret;  // was inserted.
  }
}