SequentialTableReaderScriptImpl< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for SequentialTableReaderScriptImpl< Holder >:

Collaboration diagram for SequentialTableReaderScriptImpl< Holder >:

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

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

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

Private Member Functions
bool	EnsureObjectLoaded ()
void	SetErrorState ()
void	NextScpLine ()

Private Attributes
std::string	rspecifier_
RspecifierOptions	opts_
std::string	script_rxfilename_
Input	script_input_
Input	data_input_
Holder	holder_
Holder	range_holder_
std::string	key_
std::string	data_rxfilename_
std::string	range_
enum kaldi::SequentialTableReaderScriptImpl::StateType	state_

Detailed Description

template<class Holder>
class kaldi::SequentialTableReaderScriptImpl< Holder >

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

Member Typedef Documentation

T

typedef Holder::T T

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

Member Enumeration Documentation

StateType

enum StateType

private

Enumerator
kUninitialized
kFileStart
kEof
kError
kHaveScpLine
kHaveObject
kHaveRange

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

                 {
    //  Summary of the states this object can be in (state_).
    //
    //                (*) Does holder_ contain the object corresponding to
    //                    data_rxfilename_ ?
    //                    (*) Does range_holder_ contain a range object?
    //                         (*) is script_input_ open?
    //                             (*) are key_, data_rxfilename_ and range_ [if applicable] set?
    //
    kUninitialized, // no  no  no  no            Uninitialized or closed object.
    kFileStart,     // no  no  yes no            We just opened the .scp file (we'll never be in this
                    //                           state when a user-visible function is called.)
    kEof,           // no  no  no  no            We did Next() and found eof in script file.
    kError,         // no  no  no  no            Error reading or parsing script file.
    kHaveScpLine,   // no  no  yes yes           Have a line of the script file but nothing else.
    kHaveObject,    // yes no  yes yes           holder_ contains an object but range_holder_ does not.
    kHaveRange,     // yes yes yes yes           we have the range object in range_holder_ (implies
                    //                           range_ nonempty).
  } state_;

Constructor & Destructor Documentation

SequentialTableReaderScriptImpl()

SequentialTableReaderScriptImpl ( )

inline

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

: state_(kUninitialized) { }

~SequentialTableReaderScriptImpl()

virtual ~SequentialTableReaderScriptImpl ( )

inlinevirtual

Definition at line 277 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: reading script file failed: from scp "
                      << PrintableRxfilename(script_rxfilename_);
  }

Member Function Documentation

Close()

virtual bool Close ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

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

                       {
    int32 status = 0;
    if (script_input_.IsOpen())
      status = script_input_.Close();
    if (data_input_.IsOpen())
      data_input_.Close();
    range_holder_.Clear();
    holder_.Clear();
    if (!this->IsOpen())
      KALDI_ERR << "Close() called on input that was not open.";
    StateType old_state = state_;
    state_ = kUninitialized;
    if (old_state == kError || (old_state == kEof && status != 0)) {
      if (opts_.permissive) {
        KALDI_WARN << "Close() called on scp file with read error, ignoring the"
            " error because permissive mode specified.";
        return true;
      } else {
        return false;  // User will do something with the error status.
      }
    } else {
      return true;
    }
    // Possible states                                          Return value
    // kLoadSucceeded/kRangeSucceeded/kRangeFailed              true
    // kError (if opts_.permissive)                             true
    // kError (if !opts_.permissive)                            false
    // kEof (if script_input_.Close() && !opts.permissive)      false
    // kEof (if !script_input_.Close() || opts.permissive)      true
    // kUninitialized/kFileStart/kHaveScpLine                   true
    // kUnitialized                                             true
  }

Done()

virtual bool Done ( ) const

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

                            {
    switch (state_) {
      case kHaveScpLine: case kHaveObject: case kHaveRange: return false;
      case kEof: case kError: return true;  // Error condition, like Eof, counts
        // as Done(); the destructor/Close() will inform the user of the error.
      default: KALDI_ERR << "Done() called on TableReader object at the wrong"
          " time.";
        return false;
    }
  }

EnsureObjectLoaded()

bool EnsureObjectLoaded ( )

inlineprivate

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

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

                            {
    if (!(state_ == kHaveScpLine || state_ == kHaveObject ||
          state_ == kHaveRange))
      KALDI_ERR << "Invalid state (code error)";

    if (state_ == kHaveScpLine) {  // need to load the object into holder_.
      bool ans;
      // note, NULL means it doesn't read the binary-mode header
      if (Holder::IsReadInBinary()) {
        ans = data_input_.Open(data_rxfilename_, NULL);
      } else {
        ans = data_input_.OpenTextMode(data_rxfilename_);
      }
      if (!ans) {
        KALDI_WARN << "Failed to open file "
                   << PrintableRxfilename(data_rxfilename_);
        return false;
      } else {
        if (holder_.Read(data_input_.Stream())) {
          state_ = kHaveObject;
        } else {  // holder_ will not contain data.
          KALDI_WARN << "Failed to load object from "
                     << PrintableRxfilename(data_rxfilename_);
          return false;
        }
      }
    }
    // OK, at this point the state must be either
    // kHaveObject or kHaveRange.
    if (range_.empty()) {
      // if range_ is the empty string, we should not be in the state
      // kHaveRange.
      KALDI_ASSERT(state_ == kHaveObject);
      return true;
    }
    // range_ is nonempty.
    if (state_ == kHaveRange) {
      // range was already extracted, so there nothing to do.
      return true;
    }
    // OK, range_ is nonempty and state_ is kHaveObject.  We attempt to extract
    // the range object.  Note: ExtractRange() will throw with KALDI_ERR if the
    // object type doesn't support ranges.
    if (!range_holder_.ExtractRange(holder_, range_)) {
      KALDI_WARN  << "Failed to load object from "
                  << PrintableRxfilename(data_rxfilename_)
                  << "[" << range_ << "]";
      return false;
    } else {
      state_ = kHaveRange;
      return true;
    }
  }

FreeCurrent()

void FreeCurrent ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_WARN.

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

IsOpen()

virtual bool IsOpen ( ) const

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

                              {
    switch (state_) {
      case kEof: case kHaveScpLine: case kHaveObject: case kHaveRange:
        return true;
      case kUninitialized: case kError:
        return false;
      default: KALDI_ERR << "IsOpen() called on invalid object.";
        // note: kFileStart is not a valid state for the user to call a member
        // function (we never return from a public function in this state).
        return false;
    }
  }

Key()

virtual std::string Key ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ERR.

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

Next()

void Next ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References SequentialTableReaderImplBase< Holder >::Done().

              {
    while (1) {
      NextScpLine();
      if (Done()) return;
      if (opts_.permissive) {
        // Permissive mode means, when reading scp files, we treat keys whose
        // scp entry cannot be read as nonexistent.  This means trying to read.
        if (EnsureObjectLoaded()) return;  // Success.
        // else try the next scp line.
      } else {
        return;  // We go the next key; Value() will crash if we can't read the
                 // object on the scp line.
      }
    }
  }

NextScpLine()

void NextScpLine ( )

inlineprivate

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

References kaldi::ExtractRangeSpecifier(), KALDI_ERR, KALDI_WARN, and kaldi::SplitStringOnFirstSpace().

                     {
    switch (state_) {  // Check and simplify the state.
      case kHaveRange:
        range_holder_.Clear();
        state_ = kHaveObject;
        break;
      case kHaveScpLine: case kHaveObject: case kFileStart: break;
      default:
        // No other states are valid to call Next() from.
        KALDI_ERR << "Reading script file: Next called wrongly.";
    }
    // at this point the state will be kHaveObject, kHaveScpLine, or kFileStart.
    std::string line;
    if (getline(script_input_.Stream(), line)) {
      // After extracting "key" from "line", we put the rest
      // of "line" into "rest", and then extract data_rxfilename_
      // (e.g. 1.ark:100) and possibly the range_ specifer
      // (e.g. [1:2,2:10]) from "rest".
      std::string data_rxfilename, rest;
      SplitStringOnFirstSpace(line, &key_, &rest);
      if (!key_.empty() && !rest.empty()) {
        // Got a valid line.
        if (rest[rest.size()-1] == ']') {
          if(!ExtractRangeSpecifier(rest, &data_rxfilename, &range_)) {
            KALDI_WARN << "Reading rspecifier '" << rspecifier_
                       << ", cannot make sense of scp line "
                       << line;
            SetErrorState();
            return;
          }
        } else {
          data_rxfilename = rest;
          range_ = "";
        }
        bool filenames_equal = (data_rxfilename_ == data_rxfilename);
        if (!filenames_equal)
          data_rxfilename_ = data_rxfilename;
        if (state_ == kHaveObject) {
          if (!filenames_equal) {
            holder_.Clear();
            state_ = kHaveScpLine;
          }
          // else leave state_ at kHaveObject and leave the object in the
          // holder.
        } else {
          state_ = kHaveScpLine;
        }
      } else {
        KALDI_WARN << "We got an invalid line in the scp file. "
                   << "It should look like: some_key 1.ark:10, got: "
                   << line;
        SetErrorState();
      }
    } else {
      state_ = kEof;  // there is nothing more in the scp file.  Might as well
                      // close input streams as we don't need them.
      script_input_.Close();
      if (data_input_.IsOpen())
        data_input_.Close();
      holder_.Clear();  // clear the holder if it was nonempty.
      range_holder_.Clear();  // clear the range holder if it was nonempty.
    }
  }

Open()

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

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

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

                                                 {
    if (state_ != kUninitialized && state_ != kError)
      if (!Close())  // call Close() yourself to suppress this exception.
        KALDI_ERR << "Error closing previous input: "
                  << "rspecifier was " << rspecifier_;
    bool binary;
    rspecifier_ = rspecifier;
    RspecifierType rs = ClassifyRspecifier(rspecifier, &script_rxfilename_,
                                           &opts_);
    KALDI_ASSERT(rs == kScriptRspecifier);
    if (!script_input_.Open(script_rxfilename_, &binary)) {  // Failure on Open
      KALDI_WARN << "Failed to open script file "
                 << PrintableRxfilename(script_rxfilename_);
      state_ = kUninitialized;
      return false;
    } else {  // Open succeeded.
      if (binary) {
        KALDI_WARN << "Script file should not be binary file.";
        SetErrorState();
        return false;
      } else {
        state_ = kFileStart;
        Next();
        if (state_ == kError)
          return false;
        // any other status, including kEof, is OK from the point of view of
        // the 'open' function (empty scp file is not inherently an error).
        return true;
      }
    }
  }

SetErrorState()

void SetErrorState ( )

inlineprivate

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

                       {
    state_ = kError;
    script_input_.Close();
    data_input_.Close();
    holder_.Clear();
    range_holder_.Clear();
  }

SwapHolder()

void SwapHolder ( Holder *  other_holder )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

Definition at line 191 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.  It will cause the
    // program to die with KALDI_ERR if we couldn't get a value.
    (void) Value();
    // At this point we know that we successfully loaded an object,
    // and if there was a range specified, it's in range_holder_.
    if (state_ == kHaveObject) {
      holder_.Swap(other_holder);
      state_ = kHaveScpLine;
    } else if (state_ == kHaveRange) {
      range_holder_.Swap(other_holder);
      state_ = kHaveObject;
      // This indicates that we still have the base object (but no range).
    } else {
      KALDI_ERR << "Code error";
    }
    // Note: after this call there may be some junk left in range_holder_ or
    // holder_, but it won't matter.  We avoid calling Clear() on them, as this
    // function needs to be lightweight for the 'bg' feature to work well.
  }

Value()

T& Value ( )

inlinevirtual

Implements SequentialTableReaderImplBase< Holder >.

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

References KALDI_ASSERT, KALDI_ERR, and kaldi::PrintableRxfilename().

             {
    if (!EnsureObjectLoaded())
      KALDI_ERR << "Failed to load object from "
                << PrintableRxfilename(data_rxfilename_)
                << " (to suppress this error, add the permissive "
                << "(p, ) option to the rspecifier.";
    // Because EnsureObjectLoaded() returned with success, we know
    // that if range_ is nonempty (i.e. a range was requested), the
    // state will be kHaveRange.
    if (state_ == kHaveRange) {
      return range_holder_.Value();
    } else {
      KALDI_ASSERT(state_ == kHaveObject);
      return holder_.Value();
    }
  }

Member Data Documentation

data_input_

Input data_input_

private

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

data_rxfilename_

std::string data_rxfilename_

private

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

holder_

Holder holder_

private

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

key_

std::string key_

private

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

opts_

RspecifierOptions opts_

private

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

range_

std::string range_

private

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

range_holder_

Holder range_holder_

private

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

rspecifier_

std::string rspecifier_

private

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

script_input_

Input script_input_

private

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

script_rxfilename_

std::string script_rxfilename_

private

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

state_

enum kaldi::SequentialTableReaderScriptImpl::StateType state_

private

---

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

• util/kaldi-table-inl.h