TableWriterBothImpl< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for TableWriterBothImpl< Holder >:

Collaboration diagram for TableWriterBothImpl< 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
void	MakeFilename (typename std::ostream::pos_type streampos, std::string *output) const
virtual bool	Write (const std::string &key, const T &value)
virtual void	Flush ()
virtual bool	Close ()
	TableWriterBothImpl ()
virtual	~TableWriterBothImpl ()
Public Member Functions inherited from TableWriterImplBase< Holder >
virtual	~TableWriterImplBase ()
	TableWriterImplBase ()

Private Types
enum	{ kUninitialized, kOpen, kWriteError }

Private Attributes
Output	archive_output_
Output	script_output_
WspecifierOptions	opts_
std::string	archive_wxfilename_
std::string	script_wxfilename_
std::string	wspecifier_
enum kaldi::TableWriterBothImpl:: { ... }	state_

Detailed Description

template<class Holder>
class kaldi::TableWriterBothImpl< Holder >

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

Member Typedef Documentation

T

typedef Holder::T T

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

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
kUninitialized
kOpen
kWriteError

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

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

Constructor & Destructor Documentation

TableWriterBothImpl()

TableWriterBothImpl ( )

inline

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

: state_(kUninitialized) {}

~TableWriterBothImpl()

virtual ~TableWriterBothImpl ( )

inlinevirtual

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

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

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

Member Function Documentation

Close()

virtual bool Close ( )

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

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

                       {
    if (!this->IsOpen())
      KALDI_ERR << "Close called on a stream that was not open.";
    bool close_success = true;
    if (archive_output_.IsOpen())
      if (!archive_output_.Close()) close_success = false;
    if (script_output_.IsOpen())
      if (!script_output_.Close()) close_success = false;
    bool ans = close_success && (state_ != kWriteError);
    state_ = kUninitialized;
    return ans;
  }

Flush()

virtual void Flush ( )

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

References KALDI_WARN.

                       {
    switch (state_) {
      case kWriteError: case kOpen:
        archive_output_.Stream().flush();  // Don't check error status.
        script_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 1331 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;
  }

MakeFilename()

void MakeFilename ( typename std::ostream::pos_type  streampos, std::string *  output  ) const

inline

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

References KALDI_ASSERT.

                                             {
    std::ostringstream ss;
    ss << ':' << streampos;
    KALDI_ASSERT(ss.str() != ":-1");
    *output = archive_wxfilename_ + ss.str();

    // e.g. /some/file:12302.
    // Note that we warned if archive_wxfilename_ is not an actual filename;
    // the philosophy is we give the user rope and if they want to hang
    // themselves, with it, fine.
  }

Open()

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

inlinevirtual

Implements TableWriterImplBase< Holder >.

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

References kaldi::ClassifyWspecifier(), kaldi::ClassifyWxfilename(), SequentialTableReader< Holder >::Close(), KALDI_ASSERT, KALDI_ERR, KALDI_WARN, kaldi::kBothWspecifier, and kaldi::kFileOutput.

                                                 {
    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 user.
          KALDI_ERR << "Opening stream, error closing previously open stream.";
    }
    wspecifier_ = wspecifier;
    WspecifierType ws = ClassifyWspecifier(wspecifier,
                                           &archive_wxfilename_,
                                           &script_wxfilename_,
                                           &opts_);
    KALDI_ASSERT(ws == kBothWspecifier);  // or wrongly called.
    if (ClassifyWxfilename(archive_wxfilename_) != kFileOutput)
      KALDI_WARN << "When writing to both archive and script, the script file "
          "will generally not be interpreted correctly unless the archive is "
          "an actual file: wspecifier = " << wspecifier;

    if (!archive_output_.Open(archive_wxfilename_, opts_.binary, false)) {
      // false means no binary header.
      state_ = kUninitialized;
      return false;
    }
    if (!script_output_.Open(script_wxfilename_, false, false)) {  // first
      // false means text mode: script files always text-mode.   second false
      //  means don't write header (doesn't matter for text mode).
      archive_output_.Close();  // Don't care about status: error anyway.
      state_ = kUninitialized;
      return false;
    }
    state_ = kOpen;
    return true;
  }

Write()

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

inlinevirtual

Implements TableWriterImplBase< Holder >.

Definition at line 1355 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.  Warn about it.
        KALDI_WARN << "Writing to non-open TableWriter object.";
        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;
    std::ostream &archive_os = archive_output_.Stream();
    archive_os << key << ' ';
    typename std::ostream::pos_type archive_os_pos = archive_os.tellp();
    // position at start of Write() to archive.  We will record this in the
    // script file.
    std::string offset_rxfilename;  // rxfilename with offset into the archive,
    // e.g. some_archive_name.ark:431541423
    MakeFilename(archive_os_pos, &offset_rxfilename);

    // Write to the script file first.
    // The idea is that we want to get all the information possible into the
    // script file, to make it easier to unwind errors later.
    std::ostream &script_os = script_output_.Stream();
    script_output_.Stream() << key << ' ' << offset_rxfilename << '\n';

    if (!Holder::Write(archive_output_.Stream(), opts_.binary, value)) {
      KALDI_WARN << "Write failure to"
                 << PrintableWxfilename(archive_wxfilename_);
      state_ = kWriteError;
      return false;
    }

    if (script_os.fail()) {
      KALDI_WARN << "Write failure to script file detected: "
                 << PrintableWxfilename(script_wxfilename_);
      state_ = kWriteError;
      return false;
    }

    if (archive_os.fail()) {
      KALDI_WARN << "Write failure to archive file detected: "
                 << 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_output_

Output archive_output_

private

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

archive_wxfilename_

std::string archive_wxfilename_

private

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

opts_

WspecifierOptions opts_

private

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

script_output_

Output script_output_

private

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

script_wxfilename_

std::string script_wxfilename_

private

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

state_

enum { ... } state_

wspecifier_

std::string wspecifier_

private

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

---

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

• util/kaldi-table-inl.h