TableWriterArchiveImpl< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for TableWriterArchiveImpl< Holder >:

Collaboration diagram for TableWriterArchiveImpl< Holder >:

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

Public Member Functions
virtual bool	Open (const std::string &wspecifier)
virtual bool	IsOpen () const
virtual bool	Write (const std::string &key, const T &value)
virtual void	Flush ()
virtual bool	Close ()
	TableWriterArchiveImpl ()
virtual	~TableWriterArchiveImpl ()
Public Member Functions inherited from TableWriterImplBase< Holder >
virtual	~TableWriterImplBase ()
	TableWriterImplBase ()

Private Types
enum	{ kUninitialized, kOpen, kWriteError }

Private Attributes
Output	output_
WspecifierOptions	opts_
std::string	wspecifier_
std::string	archive_wxfilename_
enum kaldi::TableWriterArchiveImpl:: { ... }	state_

Detailed Description

template<class Holder>
class kaldi::TableWriterArchiveImpl< Holder >

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

Member Typedef Documentation

T

typedef Holder::T T

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

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
kUninitialized
kOpen
kWriteError

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

       {               // is stream open?
    kUninitialized,    // no
    kOpen,             // yes
    kWriteError,       // yes
  } state_;

Constructor & Destructor Documentation

TableWriterArchiveImpl()

TableWriterArchiveImpl ( )

inline

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

: state_(kUninitialized) {}

~TableWriterArchiveImpl()

virtual ~TableWriterArchiveImpl ( )

inlinevirtual

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

References SequentialTableReader< Holder >::Close(), SequentialTableReader< Holder >::IsOpen(), and KALDI_ERR.

                                    {
    if (!IsOpen()) return;
    else if (!Close())
      KALDI_ERR << "At TableWriter destructor: Write failed or stream close "
                << "failed: wspecifier is "<<  wspecifier_;
  }

Member Function Documentation

Close()

virtual bool Close ( )

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

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

                       {
    if (!this->IsOpen() || !output_.IsOpen())
      KALDI_ERR << "Close called on a stream that was not open."
                << this->IsOpen() << ", " << output_.IsOpen();
    bool close_success = output_.Close();
    if (!close_success) {
      KALDI_WARN << "Error closing stream: wspecifier is " << wspecifier_;
      state_ = kUninitialized;
      return false;
    }
    if (state_ == kWriteError) {
      KALDI_WARN << "Closing writer in error state: wspecifier is "
                 << wspecifier_;
      state_ = kUninitialized;
      return false;
    }
    state_ = kUninitialized;
    return true;
  }

Flush()

virtual void Flush ( )

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

References KALDI_WARN.

                       {
    switch (state_) {
      case kWriteError: case kOpen:
        output_.Stream().flush();  // Don't check error status.
        return;
      default:
        KALDI_WARN << "Flush called on not-open writer.";
    }
  }

IsOpen()

virtual bool IsOpen ( ) const

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

References KALDI_ERR.

                              {
    switch (state_) {
      case kUninitialized: return false;
      case kOpen: case kWriteError: return true;
      default: KALDI_ERR << "IsOpen() called on TableWriter in invalid state.";
    }
    return false;
  }

Open()

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

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

References kaldi::ClassifyWspecifier(), SequentialTableReader< Holder >::Close(), KALDI_ASSERT, KALDI_ERR, and kaldi::kArchiveWspecifier.

                                                 {
    switch (state_) {
      case kUninitialized:
        break;
      case kWriteError:
        KALDI_ERR << "Opening stream, already open with write error.";
      case kOpen: default:
        if (!Close())  // throw because this error may not have been previously
          // detected by the user.
          KALDI_ERR << "Opening stream, error closing previously open stream.";
    }
    wspecifier_ = wspecifier;
    WspecifierType ws = ClassifyWspecifier(wspecifier,
                                           &archive_wxfilename_,
                                           NULL,
                                           &opts_);
    KALDI_ASSERT(ws == kArchiveWspecifier);  // or wrongly called.

    if (output_.Open(archive_wxfilename_, opts_.binary, false)) {  // false
                                                      // means no binary header.
      state_ = kOpen;
      return true;
    } else {
      // stream will not be open.  User will report this error
      // (we return bool), so don't bother printing anything.
      state_ = kUninitialized;
      return false;
    }
  }

Write()

virtual bool Write ( const std::string &  key, const T &  value  )

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

References kaldi::IsToken(), KALDI_ERR, KALDI_WARN, and kaldi::PrintableWxfilename().

                                                           {
    switch (state_) {
      case kOpen: break;
      case kWriteError:
        // user should have known from the last
        // call to Write that there was a problem.
        KALDI_WARN << "Attempting to write to invalid stream.";
        return false;
      case kUninitialized: default:
        KALDI_ERR << "Write called on invalid stream";
    }
    // state is now kOpen or kWriteError.
    if (!IsToken(key))  // e.g. empty string or has spaces...
      KALDI_ERR << "Using invalid key " << key;
    output_.Stream() << key << ' ';
    if (!Holder::Write(output_.Stream(), opts_.binary, value)) {
      KALDI_WARN << "Write failure to "
                 << PrintableWxfilename(archive_wxfilename_);
      state_ = kWriteError;
      return false;
    }
    if (state_ == kWriteError) return false;  // Even if this Write seems to
    // have succeeded, we fail because a previous Write failed and the archive
    // may be corrupted and unreadable.

    if (opts_.flush)
      Flush();
    return true;
  }

Member Data Documentation

archive_wxfilename_

std::string archive_wxfilename_

private

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

opts_

WspecifierOptions opts_

private

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

output_

Output output_

private

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

state_

enum { ... } state_

wspecifier_

std::string wspecifier_

private

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

---

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

• util/kaldi-table-inl.h