BasicVectorVectorHolder< BasicType > Class Template Reference

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

#include <kaldi-holder-inl.h>

Collaboration diagram for BasicVectorVectorHolder< BasicType >:

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

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

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 (BasicVectorVectorHolder)

Private Attributes
T	t_

Detailed Description

template<class BasicType>
class kaldi::BasicVectorVectorHolder< BasicType >

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

std::vector<std::vector<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 343 of file kaldi-holder-inl.h.

Member Typedef Documentation

T

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

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

Constructor & Destructor Documentation

BasicVectorVectorHolder()

BasicVectorVectorHolder ( )

inline

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

{ }

~BasicVectorVectorHolder()

~BasicVectorVectorHolder ( )

inline

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

References KaldiObjectHolder< KaldiType >::KALDI_DISALLOW_COPY_AND_ASSIGN().

{ }

Member Function Documentation

Clear()

void Clear ( )

inline

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

References KaldiObjectHolder< KaldiType >::t_.

{ t_.clear(); }

ExtractRange()

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

inline

Definition at line 476 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 468 of file kaldi-holder-inl.h.

{ return true; }

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( BasicVectorVectorHolder< BasicType >  )

private

Read()

bool Read ( std::istream &  is )

inline

Definition at line 399 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 << "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 (!v.empty()) {
              KALDI_WARN << "No semicolon before newline (wrong format)";
              return false;
            } else {
              is.get();
              return true;
            }
          } else if (std::isspace(i)) {
            is.get();
          } else if (static_cast<char>(i) == ';') {
            t_.push_back(v);
            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 << "BasicVectorVectorHolder::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 std::vector<std::vector<BasicType> >::iterator
                 iter = t_.begin();
             iter != t_.end();
             ++iter) {
          int32 size2;
          ReadBasicType(is, true, &size2);
          iter->resize(size2);
          for (typename std::vector<BasicType>::iterator iter2 = iter->begin();
               iter2 != iter->end();
               ++iter2)
            ReadBasicType(is, true, &(*iter2));
        }
        return true;
      } catch(...) {
        KALDI_WARN << "Read error or unexpected data at archive entry beginning"
            " at file position " << filepos;
        return false;
      }
    }
  }

Swap()

void Swap ( BasicVectorVectorHolder< BasicType > *  other )

inline

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

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

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

Value()

T& Value ( )

inline

Definition at line 470 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 349 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 std::vector<std::vector<BasicType> >::const_iterator
                 iter = t.begin();
             iter != t.end(); ++iter) {
          KALDI_ASSERT(static_cast<size_t>(static_cast<int32>(iter->size()))
                       == iter->size());
          WriteBasicType(os, binary, static_cast<int32>(iter->size()));
          for (typename std::vector<BasicType>::const_iterator
                   iter2 = iter->begin();
               iter2 != iter->end(); ++iter2) {
            WriteBasicType(os, binary, *iter2);
          }
        }
      } else {  // text mode...
        // In text mode, we write out something like (for integers):
        // "1 2 3 ; 4 5 ; 6 ; ; 7 8 9 ;\n"
        // where the semicolon is a terminator, not a separator
        // (a separator would cause ambiguity between an
        // empty list, and a list containing a single empty list).
        for (typename std::vector<std::vector<BasicType> >::const_iterator
                 iter = t.begin();
             iter != t.end();
             ++iter) {
          for (typename std::vector<BasicType>::const_iterator
                   iter2 = iter->begin();
               iter2 != iter->end(); ++iter2)
            WriteBasicType(os, binary, *iter2);
          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 485 of file kaldi-holder-inl.h.

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

---

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

• util/kaldi-holder-inl.h