RandomAccessTableReaderArchiveImplBase< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for RandomAccessTableReaderArchiveImplBase< Holder >:

Collaboration diagram for RandomAccessTableReaderArchiveImplBase< Holder >:

Public Types
typedef Holder::T	T
Public Types inherited from RandomAccessTableReaderImplBase< Holder >
typedef Holder::T	T

Public Member Functions
	RandomAccessTableReaderArchiveImplBase ()
virtual bool	Open (const std::string &rspecifier)
void	ReadNextObject ()
virtual bool	IsOpen () const
bool	CloseInternal ()
	~RandomAccessTableReaderArchiveImplBase ()
Public Member Functions inherited from RandomAccessTableReaderImplBase< Holder >
virtual bool	HasKey (const std::string &key)=0
virtual const T &	Value (const std::string &key)=0
virtual bool	Close ()=0
virtual	~RandomAccessTableReaderImplBase ()

Protected Types
enum	{   kUninitialized, kNoObject, kHaveObject, kEof,   kError }

Protected Attributes
std::string	cur_key_
Holder *	holder_
std::string	rspecifier_
std::string	archive_rxfilename_
RspecifierOptions	opts_
enum kaldi::RandomAccessTableReaderArchiveImplBase:: { ... }	state_

Private Attributes
Input	input_

Detailed Description

template<class Holder>
class kaldi::RandomAccessTableReaderArchiveImplBase< Holder >

Definition at line 1895 of file kaldi-table-inl.h.

Member Typedef Documentation

T

typedef Holder::T T

Definition at line 1898 of file kaldi-table-inl.h.

Member Enumeration Documentation

anonymous enum

anonymous enum

protected

Enumerator
kUninitialized
kNoObject
kHaveObject
kEof
kError

Definition at line 2031 of file kaldi-table-inl.h.

       {  //  [The state of the reading process]        [does holder_ [is input_
    //                                                      have object]   open]
    kUninitialized,  // Uninitialized or closed                   no         no
    kNoObject,      // Do not have object in holder_              no         yes
    kHaveObject,    // Have object in holder_                     yes        yes
    kEof,           // End of file                                no         yes
    kError,         // Some kind of error-state in the reading.   no         yes
  } state_;

Constructor & Destructor Documentation

RandomAccessTableReaderArchiveImplBase()

RandomAccessTableReaderArchiveImplBase ( )

inline

Definition at line 1900 of file kaldi-table-inl.h.

                                          : holder_(NULL),
                                            state_(kUninitialized) { }

~RandomAccessTableReaderArchiveImplBase()

~RandomAccessTableReaderArchiveImplBase ( )

inline

Definition at line 2015 of file kaldi-table-inl.h.

References KALDI_ASSERT.

                                            {
    // The child class has the responsibility to call CloseInternal().
    KALDI_ASSERT(state_ == kUninitialized && holder_ == NULL);
  }

Member Function Documentation

CloseInternal()

bool CloseInternal ( )

inline

Definition at line 1993 of file kaldi-table-inl.h.

References TableWriter< Holder >::IsOpen(), KALDI_ASSERT, KALDI_ERR, and KALDI_WARN.

                       {
    if (!this->IsOpen())
      KALDI_ERR << "Close() called on TableReader twice or otherwise wrongly.";
    if (input_.IsOpen())
      input_.Close();
    if (state_ == kHaveObject) {
      KALDI_ASSERT(holder_ != NULL);
      delete holder_;
      holder_ = NULL;
    } else {
      KALDI_ASSERT(holder_ == NULL);
    }
    bool ans = (state_ != kError);
    state_ = kUninitialized;
    if (!ans && opts_.permissive) {
      KALDI_WARN << "Error state detected closing reader.  "
                 << "Ignoring it because you specified permissive mode.";
      return true;
    }
    return ans;
  }

IsOpen()

virtual bool IsOpen ( ) const

inlinevirtual

Definition at line 1982 of file kaldi-table-inl.h.

References KALDI_ERR.

                              {
    switch (state_) {
      case kEof: case kError: case kHaveObject: case kNoObject: return true;
      case kUninitialized: return false;
      default: KALDI_ERR << "IsOpen() called on invalid object.";
        return false;
    }
  }

Open()

virtual bool Open ( const std::string &  rspecifier )

inlinevirtual

Implements RandomAccessTableReaderImplBase< Holder >.

Definition at line 1903 of file kaldi-table-inl.h.

References kaldi::ClassifyRspecifier(), TableWriter< Holder >::Close(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, kaldi::kArchiveRspecifier, and kaldi::PrintableRxfilename().

                                                 {
    if (state_ != kUninitialized) {
      if (!this->Close())  // call Close() yourself to suppress this exception.
        KALDI_ERR << "Error closing previous input.";
    }
    rspecifier_ = rspecifier;
    RspecifierType rs = ClassifyRspecifier(rspecifier, &archive_rxfilename_,
                                           &opts_);
    KALDI_ASSERT(rs == kArchiveRspecifier);

    // NULL means don't expect binary-mode header
    bool ans;
    if (Holder::IsReadInBinary())
      ans = input_.Open(archive_rxfilename_, NULL);
    else
      ans = input_.OpenTextMode(archive_rxfilename_);
    if (!ans) {  // header.
      KALDI_WARN << "Failed to open stream "
                 << PrintableRxfilename(archive_rxfilename_);
      state_ = kUninitialized;  // Failure on Open
      return false;  // User should print the error message.
    } else {
      state_ = kNoObject;
    }
    return true;
  }

ReadNextObject()

void ReadNextObject ( )

inline

Definition at line 1935 of file kaldi-table-inl.h.

References kaldi::CharToString(), KALDI_ERR, KALDI_WARN, and kaldi::PrintableRxfilename().

                        {
    if (state_ != kNoObject)
      KALDI_ERR << "ReadNextObject() called from wrong state.";
    // Code error somewhere in this class or a child class.
    std::istream &is = input_.Stream();
    is.clear();  // Clear any fail bits that may have been set... just in case
    // this happened in the Read function.
    is >> cur_key_;  // This eats up any leading whitespace and gets the string.
    if (is.eof()) {
      state_ = kEof;
      return;
    }
    if (is.fail()) {  // This shouldn't really happen, barring file-system
                      // errors.
      KALDI_WARN << "Error reading archive: rspecifier is " << rspecifier_;
      state_ = kError;
      return;
    }
    int c;
    if ((c = is.peek()) != ' ' && c != '\t' && c != '\n') {  // We expect a
      // space ' ' after the key.
      // We also allow tab, just so we can read archives generated by scripts
      // that may not be fully aware of how this format works.
      KALDI_WARN << "Invalid archive file format: expected space after key "
                 <<cur_key_
                 <<", got character "
                 << CharToString(static_cast<char>(is.peek()))
                 << ", reading archive "
                 << PrintableRxfilename(archive_rxfilename_);
      state_ = kError;
      return;
    }
    if (c != '\n') is.get();  // Consume the space or tab.
    holder_ = new Holder;
    if (holder_->Read(is)) {
      state_ = kHaveObject;
      return;
    } else {
      KALDI_WARN << "Object read failed, reading archive "
                 << PrintableRxfilename(archive_rxfilename_);
      state_ = kError;
      delete holder_;
      holder_ = NULL;
      return;
    }
  }

Member Data Documentation

archive_rxfilename_

std::string archive_rxfilename_

protected

Definition at line 2028 of file kaldi-table-inl.h.

cur_key_

std::string cur_key_

protected

Definition at line 2024 of file kaldi-table-inl.h.

holder_

Holder* holder_

protected

Definition at line 2025 of file kaldi-table-inl.h.

input_

Input input_

private

Definition at line 2020 of file kaldi-table-inl.h.

opts_

RspecifierOptions opts_

protected

Definition at line 2029 of file kaldi-table-inl.h.

rspecifier_

std::string rspecifier_

protected

Definition at line 2027 of file kaldi-table-inl.h.

state_

enum { ... } state_

---

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

• util/kaldi-table-inl.h