SequentialTableReaderArchiveImpl< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for SequentialTableReaderArchiveImpl< Holder >:

Collaboration diagram for SequentialTableReaderArchiveImpl< Holder >:

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

Public Member Functions
	SequentialTableReaderArchiveImpl ()
virtual bool	Open (const std::string &rspecifier)
virtual void	Next ()
virtual bool	IsOpen () const
virtual bool	Done () const
virtual std::string	Key ()
T &	Value ()
virtual void	FreeCurrent ()
void	SwapHolder (Holder *other_holder)
virtual bool	Close ()
virtual	~SequentialTableReaderArchiveImpl ()
Public Member Functions inherited from SequentialTableReaderImplBase< Holder >
	SequentialTableReaderImplBase ()
virtual	~SequentialTableReaderImplBase ()

Private Types
enum	StateType {   kUninitialized, kFileStart, kEof, kError,   kHaveObject, kFreedObject }

Private Attributes
Input	input_
Holder	holder_
std::string	key_
std::string	rspecifier_
std::string	archive_rxfilename_
RspecifierOptions	opts_
enum kaldi::SequentialTableReaderArchiveImpl::StateType	state_

Detailed Description

template<class Holder>
class kaldi::SequentialTableReaderArchiveImpl< Holder >

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

Member Typedef Documentation

T

typedef Holder::T T

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

Member Enumeration Documentation

StateType

enum StateType

private

Enumerator
kUninitialized
kFileStart
kEof
kError
kHaveObject
kFreedObject

Definition at line 688 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
    kFileStart,      // [state we use internally: just opened.]   no         yes
    kEof,     // We did Next() and found eof in archive           no         no
    kError,   // Some other error                                 no         no
    kHaveObject,  // We read the key and the object after it.     yes        yes
    kFreedObject,  // The user called FreeCurrent().              no         yes
  } state_;

Constructor & Destructor Documentation

SequentialTableReaderArchiveImpl()

SequentialTableReaderArchiveImpl ( )

inline

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

: state_(kUninitialized) { }

~SequentialTableReaderArchiveImpl()

virtual ~SequentialTableReaderArchiveImpl ( )

inlinevirtual

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

References SequentialTableReaderImplBase< Holder >::Close(), SequentialTableReaderImplBase< Holder >::IsOpen(), KALDI_ERR, and kaldi::PrintableRxfilename().

                                              {
    if (this->IsOpen() && !Close())
      KALDI_ERR << "TableReader: error detected closing archive "
                << PrintableRxfilename(archive_rxfilename_);
  }

Member Function Documentation

Close()

virtual bool Close ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References SequentialTableReaderImplBase< Holder >::IsOpen(), KALDI_ERR, KALDI_WARN, and kaldi::PrintableRxfilename().

                       {
    // To clean up, Close() also closes the Input object if
    // it's open.  It will succeed if the stream was not in an error state,
    // and the Input object isn't in an error state  we've found eof in the archive.
    if (!this->IsOpen())
      KALDI_ERR << "Close() called on TableReader twice or otherwise wrongly.";
    int32 status = 0;
    if (input_.IsOpen())
      status = input_.Close();
    if (state_ == kHaveObject)
      holder_.Clear();
    StateType old_state = state_;
    state_ = kUninitialized;
    if (old_state == kError || (old_state == kEof && status != 0)) {
      if (opts_.permissive) {
        KALDI_WARN << "Error detected closing TableReader for archive "
                   << PrintableRxfilename(archive_rxfilename_)
                   << " but ignoring "
                   << "it as permissive mode specified.";
        return true;
      } else {
        return false;
      }
    } else {
      return true;
    }
  }

Done()

virtual bool Done ( ) const

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

                            {
    switch (state_) {
      case kHaveObject:
        return false;
      case kEof: case kError:
        return true;  // Error-state counts as Done(), but destructor
        // will fail (unless you check the status with Close()).
      default:
        KALDI_ERR << "Done() called on TableReader object at the wrong time.";
        return false;
    }
  }

FreeCurrent()

virtual void FreeCurrent ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_WARN.

                             {
    if (state_ == kHaveObject) {
      holder_.Clear();
      state_ = kFreedObject;
    } else {
      KALDI_WARN << "FreeCurrent called at the wrong time.";
    }
  }

IsOpen()

virtual bool IsOpen ( ) const

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

                              {
    switch (state_) {
      case kEof: case kError: case kHaveObject: case kFreedObject: return true;
      case kUninitialized: return false;
      default: KALDI_ERR << "IsOpen() called on invalid object.";  // kFileStart
        // is not valid state for user to call something on.
        return false;
    }
  }

Key()

virtual std::string Key ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

                          {
    // Valid to call this whenever Done() returns false
    switch (state_) {
      case kHaveObject: break;  // only valid case.
      default:
        // coding error.
        KALDI_ERR << "Key() called on TableReader object at the wrong time.";
    }
    return key_;
  }

Next()

virtual void Next ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

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

                      {
    switch (state_) {
      case kHaveObject:
        holder_.Clear();
        break;
      case kFileStart: case kFreedObject:
        break;
      default:
        KALDI_ERR << "Next() called wrongly.";
    }
    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 >> 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 "
                 << PrintableRxfilename(archive_rxfilename_);
      state_ = kError;
      return;
    }
    int c;
    if ((c = is.peek()) != ' ' && c != '\t' && c != '\n') {  // We expect a
                                                     // space ' ' after the key.
      // We also allow tab [which is consumed] and newline [which is not], 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 "
                 << key_ << ", got character "
                 << CharToString(static_cast<char>(is.peek())) << ", reading "
                 << PrintableRxfilename(archive_rxfilename_);
      state_ = kError;
      return;
    }
    if (c != '\n') is.get();  // Consume the space or tab.
    if (holder_.Read(is)) {
      state_ = kHaveObject;
      return;
    } else {
      KALDI_WARN << "Object read failed, reading archive "
                 << PrintableRxfilename(archive_rxfilename_);
      state_ = kError;
      return;
    }
  }

Open()

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

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

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

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

    bool ans;
    // NULL means don't expect binary-mode header
    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.
    }
    state_ = kFileStart;
    Next();
    if (state_ == kError) {
      KALDI_WARN << "Error beginning to read archive file (wrong filename?): "
                 << PrintableRxfilename(archive_rxfilename_);
      input_.Close();
      state_ = kUninitialized;
      return false;
    }
    KALDI_ASSERT(state_ == kHaveObject || state_ == kEof);
    return true;
  }

SwapHolder()

void SwapHolder ( Holder *  other_holder )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR, and SequentialTableReaderImplBase< Holder >::Value().

                                        {
    // call Value() to ensure we have a value, and ignore its return value while
    // suppressing compiler warnings by casting to void.
    (void) Value();
    if (state_ == kHaveObject) {
      holder_.Swap(other_holder);
      state_ = kFreedObject;
    } else {
      KALDI_ERR << "SwapHolder called at the wrong time "
                   "(error related to ',bg' modifier).";
    }
  }

Value()

T& Value ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

             {
    switch (state_) {
      case kHaveObject:
        break;  // only valid case.
      default:
        // coding error.
        KALDI_ERR << "Value() called on TableReader object at the wrong time.";
    }
    return holder_.Value();
  }

Member Data Documentation

archive_rxfilename_

std::string archive_rxfilename_

private

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

holder_

Holder holder_

private

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

input_

Input input_

private

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

key_

std::string key_

private

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

opts_

RspecifierOptions opts_

private

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

rspecifier_

std::string rspecifier_

private

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

state_

enum kaldi::SequentialTableReaderArchiveImpl::StateType state_

private

---

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

• util/kaldi-table-inl.h