#include <deterministic-fst.h>

Inheritance diagram for ComposeDeterministicOnDemandFst< Arc >:

Collaboration diagram for ComposeDeterministicOnDemandFst< Arc >:

Public Types
typedef Arc::StateId	StateId

typedef Arc::Weight	Weight

typedef Arc::Label	Label

Public Types inherited from DeterministicOnDemandFst< Arc >
typedef Arc::StateId	StateId

typedef Arc::Weight	Weight

typedef Arc::Label	Label

Public Member Functions
	ComposeDeterministicOnDemandFst (DeterministicOnDemandFst< Arc > fst1, DeterministicOnDemandFst< Arc > fst2)
	Note: constructor does not "take ownership" of the input fst's. More...

virtual StateId	Start ()

virtual Weight	Final (StateId s)

virtual bool	GetArc (StateId s, Label ilabel, Arc *oarc)
	Note: ilabel must not be epsilon. More...

Public Member Functions inherited from DeterministicOnDemandFst< Arc >
virtual	~DeterministicOnDemandFst ()

Private Types
typedef unordered_map< std::pair< StateId, StateId >, StateId, kaldi::PairHasher< StateId > >	MapType

Private Attributes
DeterministicOnDemandFst< Arc > *	fst1_

DeterministicOnDemandFst< Arc > *	fst2_

MapType	state_map_

std::vector< std::pair< StateId, StateId > >	state_vec_

StateId	next_state_

StateId	start_state_

Detailed Description

template<class Arc>
class fst::ComposeDeterministicOnDemandFst< Arc >

Definition at line 199 of file deterministic-fst.h.

Member Typedef Documentation

◆ Label

typedef Arc::Label Label

Definition at line 203 of file deterministic-fst.h.

◆ MapType

typedef unordered_map<std::pair<StateId, StateId>, StateId, kaldi::PairHasher<StateId> > MapType

private

Definition at line 221 of file deterministic-fst.h.

◆ StateId

typedef Arc::StateId StateId

Definition at line 201 of file deterministic-fst.h.

◆ Weight

typedef Arc::Weight Weight

Definition at line 202 of file deterministic-fst.h.

Constructor & Destructor Documentation

◆ ComposeDeterministicOnDemandFst()

ComposeDeterministicOnDemandFst	(	DeterministicOnDemandFst< Arc > *	fst1,
		DeterministicOnDemandFst< Arc > *	fst2
	)

Note: constructor does not "take ownership" of the input fst's.

The input fst's should be treated as const, in that their contents do not change, but they are not const as the DeterministicOnDemandFst's data-access functions are not const, for reasons relating to caching.

Definition at line 136 of file deterministic-fst-inl.h.

References ComposeDeterministicOnDemandFst< Arc >::fst1_, ComposeDeterministicOnDemandFst< Arc >::fst2_, KALDI_ASSERT, ComposeDeterministicOnDemandFst< Arc >::next_state_, ComposeDeterministicOnDemandFst< Arc >::start_state_, ComposeDeterministicOnDemandFst< Arc >::state_map_, and ComposeDeterministicOnDemandFst< Arc >::state_vec_.

                                         : fst1_(fst1), fst2_(fst2) {
   KALDI_ASSERT(fst1 != NULL && fst2 != NULL);
   if (fst1_->Start() == -1 || fst2_->Start() == -1) {
     start_state_ = -1;
     next_state_ = 0; // actually we don't care about this value.
   } else {
     start_state_ = 0;
     std::pair<StateId,StateId> start_pair(fst1_->Start(), fst2_->Start());
     state_map_[start_pair] = start_state_;
     state_vec_.push_back(start_pair);
     next_state_ = 1;
   }
 }

Member Function Documentation

◆ Final()

Arc::Weight Final ( StateId s )

virtual

Implements DeterministicOnDemandFst< Arc >.

Definition at line 153 of file deterministic-fst-inl.h.

References ComposeDeterministicOnDemandFst< Arc >::fst1_, ComposeDeterministicOnDemandFst< Arc >::fst2_, KALDI_ASSERT, ComposeDeterministicOnDemandFst< Arc >::state_vec_, and fst::Times().

                                                                         {
   KALDI_ASSERT(s < static_cast<StateId>(state_vec_.size()));
   const std::pair<StateId, StateId> &pr (state_vec_[s]);
   return Times(fst1_->Final(pr.first), fst2_->Final(pr.second));
 }

◆ GetArc()

bool GetArc	(	StateId	s,
		Label	ilabel,
		Arc *	oarc
	)

virtual

Note: ilabel must not be epsilon.

Implements DeterministicOnDemandFst< Arc >.

Definition at line 160 of file deterministic-fst-inl.h.

References ComposeDeterministicOnDemandFst< Arc >::fst1_, ComposeDeterministicOnDemandFst< Arc >::fst2_, KALDI_ASSERT, ComposeDeterministicOnDemandFst< Arc >::next_state_, ComposeDeterministicOnDemandFst< Arc >::state_map_, ComposeDeterministicOnDemandFst< Arc >::state_vec_, and fst::Times().

                                                              {
   typedef typename MapType::iterator IterType;
   KALDI_ASSERT(ilabel != 0 &&
          "This program expects epsilon-free compact lattices as input");
   KALDI_ASSERT(s < static_cast<StateId>(state_vec_.size()));
   const std::pair<StateId, StateId> pr (state_vec_[s]);
 
   Arc arc1;
   if (!fst1_->GetArc(pr.first, ilabel, &arc1)) return false;
   if (arc1.olabel == 0) { // There is no output label on the
     // arc, so only the first state changes.
     std::pair<const std::pair<StateId, StateId>, StateId> new_value(
         std::pair<StateId, StateId>(arc1.nextstate, pr.second),
         next_state_);
 
     std::pair<IterType, bool> result = state_map_.insert(new_value);
     oarc->ilabel = ilabel;
     oarc->olabel = 0;
     oarc->nextstate = result.first->second;
     oarc->weight = arc1.weight;
     if (result.second == true) { // was inserted
       next_state_++;
       const std::pair<StateId, StateId> &new_pair (new_value.first);
       state_vec_.push_back(new_pair);
     }
     return true;
   }
   // There is an output label, so we need to traverse an arc on the
   // second fst also.
   Arc arc2;
   if (!fst2_->GetArc(pr.second, arc1.olabel, &arc2)) return false;
   std::pair<const std::pair<StateId, StateId>, StateId> new_value(
       std::pair<StateId, StateId>(arc1.nextstate, arc2.nextstate),
       next_state_);
   std::pair<IterType, bool> result =
       state_map_.insert(new_value);
   oarc->ilabel = ilabel;
   oarc->olabel = arc2.olabel;
   oarc->nextstate = result.first->second;
   oarc->weight = Times(arc1.weight, arc2.weight);
   if (result.second == true) { // was inserted
     next_state_++;
     const std::pair<StateId, StateId> &new_pair (new_value.first);
     state_vec_.push_back(new_pair);
   }
   return true;
 }