BasicPairVectorHolder< BasicType > Class Template Reference

BasicPairVectorHolder is a Holder for a vector of pairs of a basic type, e.g. More...

#include <kaldi-holder-inl.h>

Collaboration diagram for BasicPairVectorHolder< BasicType >:

Public Types
typedef std::vector< std::pair< BasicType, BasicType > >	T

Public Member Functions
	BasicPairVectorHolder ()
void	Clear ()
bool	Read (std::istream &is)
T &	Value ()
void	Swap (BasicPairVectorHolder< BasicType > *other)
bool	ExtractRange (const BasicPairVectorHolder< BasicType > &other, const std::string &range)
	~BasicPairVectorHolder ()

Static Public Member Functions
static bool	Write (std::ostream &os, bool binary, const T &t)
static bool	IsReadInBinary ()

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (BasicPairVectorHolder)

Private Attributes
T	t_

Detailed Description

template<class BasicType>
class kaldi::BasicPairVectorHolder< BasicType >

BasicPairVectorHolder is a Holder for a vector of pairs of a basic type, e.g.

std::vector<std::pair<int32, int32> >. Note: a basic type is defined as a type for which ReadBasicType and WriteBasicType are implemented, i.e. integer and floating types, and bool.

Definition at line 494 of file kaldi-holder-inl.h.

Member Typedef Documentation

T

typedef std::vector<std::pair<BasicType, BasicType> > T

Definition at line 496 of file kaldi-holder-inl.h.

Constructor & Destructor Documentation

BasicPairVectorHolder()

BasicPairVectorHolder ( )

inline

Definition at line 498 of file kaldi-holder-inl.h.

{ }

~BasicPairVectorHolder()

~BasicPairVectorHolder ( )

inline

Definition at line 627 of file kaldi-holder-inl.h.

References KaldiObjectHolder< KaldiType >::KALDI_DISALLOW_COPY_AND_ASSIGN().

{ }

Member Function Documentation

Clear()

void Clear ( )

inline

Definition at line 536 of file kaldi-holder-inl.h.

References KaldiObjectHolder< KaldiType >::t_.

{ t_.clear(); }

ExtractRange()

bool ExtractRange ( const BasicPairVectorHolder< BasicType > &  other, const std::string &  range  )

inline

Definition at line 621 of file kaldi-holder-inl.h.

References KALDI_ERR.

                                            {
    KALDI_ERR << "ExtractRange is not defined for this type of holder.";
    return false;
  }

IsReadInBinary()

static bool IsReadInBinary ( )

inlinestatic

Definition at line 613 of file kaldi-holder-inl.h.

{ return true; }

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( BasicPairVectorHolder< BasicType >  )

private

Read()

bool Read ( std::istream &  is )

inline

Definition at line 539 of file kaldi-holder-inl.h.

References rnnlm::i, kaldi::InitKaldiInputStream(), KALDI_WARN, kaldi::ReadBasicType(), and KaldiObjectHolder< KaldiType >::t_.

                            {
    t_.clear();
    bool is_binary;
    if (!InitKaldiInputStream(is, &is_binary)) {
      KALDI_WARN << "Reading Table object [integer type], failed reading binary"
          " header\n";
      return false;
    }
    if (!is_binary) {
      // In text mode, we terminate with newline.
      try {  // catching errors from ReadBasicType..
        std::vector<BasicType> v;  // temporary vector
        while (1) {
          int i = is.peek();
          if (i == -1) {
            KALDI_WARN << "Unexpected EOF";
            return false;
          } else if (static_cast<char>(i) == '\n') {
            if (t_.empty() && v.empty()) {
              is.get();
              return true;
            } else if (v.size() == 2) {
              t_.push_back(std::make_pair(v[0], v[1]));
              is.get();
              return true;
            } else {
              KALDI_WARN << "Unexpected newline, reading vector<pair<?> >; got "
                         << v.size() << " elements, expected 2.";
              return false;
            }
          } else if (std::isspace(i)) {
            is.get();
          } else if (static_cast<char>(i) == ';') {
            if (v.size() != 2) {
              KALDI_WARN << "Wrong input format, reading vector<pair<?> >; got "
                         << v.size() << " elements, expected 2.";
              return false;
            }
            t_.push_back(std::make_pair(v[0], v[1]));
            v.clear();
            is.get();
          } else {  // some object we want to read...
            BasicType b;
            ReadBasicType(is, false, &b);  // throws on error.
            v.push_back(b);
          }
        }
      } catch(const std::exception &e) {
        KALDI_WARN << "BasicPairVectorHolder::Read, read error. " << e.what();
        return false;
      }
    } else {  // binary mode.
      size_t filepos = is.tellg();
      try {
        int32 size;
        ReadBasicType(is, true, &size);
        t_.resize(size);
        for (typename T::iterator iter = t_.begin();
             iter != t_.end();
             ++iter) {
          ReadBasicType(is, true, &(iter->first));
          ReadBasicType(is, true, &(iter->second));
        }
        return true;
      } catch(...) {
        KALDI_WARN << "BasicVectorHolder::Read, read error or unexpected data"
            " at archive entry beginning at file position " << filepos;
        return false;
      }
    }
  }

Swap()

void Swap ( BasicPairVectorHolder< BasicType > *  other )

inline

Definition at line 617 of file kaldi-holder-inl.h.

References KaldiObjectHolder< KaldiType >::t_, and BasicPairVectorHolder< BasicType >::t_.

                                                     {
    t_.swap(other->t_);
  }

Value()

T& Value ( )

inline

Definition at line 615 of file kaldi-holder-inl.h.

References KaldiObjectHolder< KaldiType >::t_.

{  return t_; }

Write()

static bool Write ( std::ostream &  os, bool  binary, const T &  t  )

inlinestatic

Definition at line 500 of file kaldi-holder-inl.h.

References kaldi::InitKaldiOutputStream(), KALDI_ASSERT, KALDI_WARN, and kaldi::WriteBasicType().

                                                             {
    InitKaldiOutputStream(os, binary);  // Puts binary header if binary mode.
    try {
      if (binary) {  // need to write the size, in binary mode.
        KALDI_ASSERT(static_cast<size_t>(static_cast<int32>(t.size())) ==
                     t.size());
        // Or this Write routine cannot handle such a large vector.
        // use int32 because it's fixed size regardless of compilation.
        // change to int64 (plus in Read function) if this becomes a problem.
        WriteBasicType(os, binary, static_cast<int32>(t.size()));
        for (typename T::const_iterator iter = t.begin();
             iter != t.end(); ++iter) {
          WriteBasicType(os, binary, iter->first);
          WriteBasicType(os, binary, iter->second);
        }
      } else {  // text mode...
        // In text mode, we write out something like (for integers):
        // "1 2 ; 4 5 ; 6 7 ; 8 9 \n"
        // where the semicolon is a separator, not a terminator.
        for (typename T::const_iterator iter = t.begin();
             iter != t.end();) {
          WriteBasicType(os, binary, iter->first);
          WriteBasicType(os, binary, iter->second);
          ++iter;
          if (iter != t.end())
            os << "; ";
        }
        os << '\n';
      }
      return os.good();
    } catch(const std::exception &e) {
      KALDI_WARN << "Exception caught writing Table object. " << e.what();
      return false;  // Write failure.
    }
  }

Member Data Documentation

t_

T t_

private

Definition at line 630 of file kaldi-holder-inl.h.

Referenced by BasicPairVectorHolder< BasicType >::Swap().

---

The documentation for this class was generated from the following file:

• util/kaldi-holder-inl.h