RandomAccessTableReaderSortedArchiveImpl< Holder > Class Template Reference

#include <kaldi-table-inl.h>

Inheritance diagram for RandomAccessTableReaderSortedArchiveImpl< Holder >:

Collaboration diagram for RandomAccessTableReaderSortedArchiveImpl< Holder >:

Classes
struct	PairCompare

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

Public Member Functions
	RandomAccessTableReaderSortedArchiveImpl ()
virtual bool	Close ()
virtual bool	HasKey (const std::string &key)
virtual const T &	Value (const std::string &key)
virtual	~RandomAccessTableReaderSortedArchiveImpl ()
Public Member Functions inherited from RandomAccessTableReaderArchiveImplBase< Holder >
	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	~RandomAccessTableReaderImplBase ()

Private Member Functions
void	HandlePendingDelete ()
bool	FindKeyInternal (const std::string &key, size_t *index)

Private Attributes
std::vector< std::pair< std::string, Holder * > >	seen_pairs_
size_t	last_found_index_
size_t	pending_delete_

Additional Inherited Members
Protected Types inherited from RandomAccessTableReaderArchiveImplBase< Holder >
enum	{   kUninitialized, kNoObject, kHaveObject, kEof,   kError }
Protected Attributes inherited from RandomAccessTableReaderArchiveImplBase< Holder >
std::string	cur_key_
Holder *	holder_
std::string	rspecifier_
std::string	archive_rxfilename_
RspecifierOptions	opts_
enum kaldi::RandomAccessTableReaderArchiveImplBase:: { ... }	state_

Detailed Description

template<class Holder>
class kaldi::RandomAccessTableReaderSortedArchiveImpl< Holder >

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

Member Typedef Documentation

T

typedef Holder::T T

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

Constructor & Destructor Documentation

RandomAccessTableReaderSortedArchiveImpl()

RandomAccessTableReaderSortedArchiveImpl ( )

inline

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

                                            :
      last_found_index_(static_cast<size_t>(-1)),
      pending_delete_(static_cast<size_t>(-1)) { }

~RandomAccessTableReaderSortedArchiveImpl()

virtual ~RandomAccessTableReaderSortedArchiveImpl ( )

inlinevirtual

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

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

                                                      {
    if (this->IsOpen())
      if (!Close())  // more specific warning will already have been printed.
        // we are in some kind of error state & user did not find out by
        // calling Close().
        KALDI_ERR << "Error closing RandomAccessTableReader: rspecifier is "
                  << rspecifier_;
  }

Member Function Documentation

Close()

virtual bool Close ( )

inlinevirtual

Implements RandomAccessTableReaderImplBase< Holder >.

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

References rnnlm::i.

                       {
    for (size_t i = 0; i < seen_pairs_.size(); i++)
      delete seen_pairs_[i].second;
    seen_pairs_.clear();

    pending_delete_ = static_cast<size_t>(-1);
    last_found_index_ = static_cast<size_t>(-1);

    return this->CloseInternal();
  }

FindKeyInternal()

bool FindKeyInternal ( const std::string &  key, size_t *  index  )

inlineprivate

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

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

                                                            {
    // First, an optimization in case the previous call was for the
    // same key, and we found it.
    if (last_found_index_ < seen_pairs_.size()
       && seen_pairs_[last_found_index_].first == key) {
      *index = last_found_index_;
      return true;
    }

    if (state_ == kUninitialized)
      KALDI_ERR << "Trying to access a RandomAccessTableReader object that is"
                   " not open.";

    // Step one is to see whether we have to read ahead for the object..
    // Note, the possible states right now are kNoObject, kEof or kError.
    // We are never in the state kHaveObject except just after calling
    // ReadNextObject().
    bool looped = false;
    while (state_ == kNoObject &&
          (seen_pairs_.empty() || key.compare(seen_pairs_.back().first) > 0)) {
      looped = true;
      // Read this as:
      //  while ( the stream is potentially good for reading &&
      //        ([got no keys] || key > most_recent_key) ) { ...
      //     Try to read a new object.
      // Note that the keys in seen_pairs_ are ordered from least to greatest.
      ReadNextObject();
      if (state_ == kHaveObject) {  // Successfully read object.
        if (!seen_pairs_.empty() &&  // This is just a check.
           cur_key_.compare(seen_pairs_.back().first) <= 0) {
          // read the expression above as: !( cur_key_ > previous_key).
          // it means we are not in sorted order [the user specified that we
          // are, or we would not be using this implementation].
          KALDI_ERR << "You provided the sorted (s) option but keys in archive "
                    << PrintableRxfilename(archive_rxfilename_) << " are not "
                    << "in sorted order: " << seen_pairs_.back().first
                    << " is followed by " << cur_key_;
        }
        KALDI_ASSERT(holder_ != NULL);
        seen_pairs_.push_back(std::make_pair(cur_key_, holder_));
        holder_ = NULL;
        state_ = kNoObject;
      }
    }
    if (looped) {  // We only need to check the last element of the seen_pairs_
      // array, since we would not have read more after getting "key".
      if (!seen_pairs_.empty() && seen_pairs_.back().first == key) {
        last_found_index_ = *index = seen_pairs_.size() - 1;
        return true;
      } else {
        return false;
      }
    }
    // Now we have do an actual binary search in the seen_pairs_ array.
    std::pair<std::string, Holder*> pr(key, static_cast<Holder*>(NULL));
    typename std::vector<std::pair<std::string, Holder*> >::iterator
        iter = std::lower_bound(seen_pairs_.begin(), seen_pairs_.end(),
                                pr, PairCompare());
    if (iter != seen_pairs_.end() &&
       key == iter->first) {
      last_found_index_ = *index = (iter - seen_pairs_.begin());
      return true;
    } else {
      return false;
    }
  }

HandlePendingDelete()

void HandlePendingDelete ( )

inlineprivate

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

References KALDI_ASSERT.

                             {
    const size_t npos = static_cast<size_t>(-1);
    if (pending_delete_ != npos) {
      KALDI_ASSERT(pending_delete_ < seen_pairs_.size());
      KALDI_ASSERT(seen_pairs_[pending_delete_].second != NULL);
      delete seen_pairs_[pending_delete_].second;
      seen_pairs_[pending_delete_].second = NULL;
      pending_delete_ = npos;
    }
  }

HasKey()

virtual bool HasKey ( const std::string &  key )

inlinevirtual

Implements RandomAccessTableReaderImplBase< Holder >.

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

References KALDI_ERR.

                                            {
    HandlePendingDelete();
    size_t index;
    bool ans = FindKeyInternal(key, &index);
    if (ans && opts_.once && seen_pairs_[index].second == NULL) {
      // Just do a check RE the once option. "&&opts_.once" is for
      // efficiency since this can only happen in that case.
      KALDI_ERR << "Error: HasKey called after Value() already called for "
                << " that key, and once (o) option specified: rspecifier is "
                << rspecifier_;
    }
    return ans;
  }

Value()

virtual const T& Value ( const std::string &  key )

inlinevirtual

Implements RandomAccessTableReaderImplBase< Holder >.

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

References KALDI_ERR, and kaldi::PrintableRxfilename().

                                                {
    HandlePendingDelete();
    size_t index;
    if (!FindKeyInternal(key, &index)) {
      KALDI_ERR << "Value() called but no such key " << key
                << " in archive " << PrintableRxfilename(archive_rxfilename_);
    }
    if (seen_pairs_[index].second == NULL) {  // can happen if opts.once_
      KALDI_ERR << "Error: Value() called more than once for key "
                << key << " and once (o) option specified: rspecifier is "
                << rspecifier_;
    }
    if (opts_.once)
      pending_delete_ = index;  // mark this index to be deleted on next call.
    return seen_pairs_[index].second->Value();
  }

Member Data Documentation

last_found_index_

size_t last_found_index_

private

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

pending_delete_

size_t pending_delete_

private

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

seen_pairs_

std::vector<std::pair<std::string, Holder*> > seen_pairs_

private

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

---

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

• util/kaldi-table-inl.h