TableEventMap Class Reference

#include <event-map.h>

Inheritance diagram for TableEventMap:

Collaboration diagram for TableEventMap:

Public Member Functions
virtual bool	Map (const EventType &event, EventAnswerType *ans) const
virtual void	GetChildren (std::vector< EventMap *> *out) const
virtual void	MultiMap (const EventType &event, std::vector< EventAnswerType > *ans) const
virtual EventMap *	Prune () const
virtual EventMap *	MapValues (const unordered_set< EventKeyType > &keys_to_map, const unordered_map< EventValueType, EventValueType > &value_map) const
	TableEventMap (EventKeyType key, const std::vector< EventMap *> &table)
	Takes ownership of pointers. More...
	TableEventMap (EventKeyType key, const std::map< EventValueType, EventMap *> &map_in)
	Takes ownership of pointers. More...
	TableEventMap (EventKeyType key, const std::map< EventValueType, EventAnswerType > &map_in)
	This initializer creates a ConstantEventMap for each value in the map. More...
virtual void	Write (std::ostream &os, bool binary)
	Write to stream. More...
virtual EventMap *	Copy (const std::vector< EventMap *> &new_leaves) const
virtual	~TableEventMap ()
Public Member Functions inherited from EventMap
EventMap *	Copy () const
virtual EventAnswerType	MaxResult () const
virtual	~EventMap ()

Static Public Member Functions
static TableEventMap *	Read (std::istream &is, bool binary)
Static Public Member Functions inherited from EventMap
static void	Check (const EventType &event)
static bool	Lookup (const EventType &event, EventKeyType key, EventValueType *ans)
static void	Write (std::ostream &os, bool binary, EventMap *emap)
	a Write function that takes care of NULL pointers. More...
static EventMap *	Read (std::istream &is, bool binary)
	a Read function that reads an arbitrary EventMap; also works for NULL pointers. More...

Private Member Functions
	KALDI_DISALLOW_COPY_AND_ASSIGN (TableEventMap)

Private Attributes
EventKeyType	key_
std::vector< EventMap * >	table_

Detailed Description

Definition at line 206 of file event-map.h.

Constructor & Destructor Documentation

TableEventMap() [1/3]

TableEventMap ( EventKeyType  key, const std::vector< EventMap *> &  table  )

inlineexplicit

Takes ownership of pointers.

Definition at line 243 of file event-map.h.

: key_(key), table_(table) {}

TableEventMap() [2/3]

TableEventMap ( EventKeyType  key, const std::map< EventValueType, EventMap *> &  map_in  )

explicit

Takes ownership of pointers.

Definition at line 325 of file event-map.cc.

References KALDI_ASSERT, and TableEventMap::table_.

                                                                                             : key_(key) {
  if (map_in.size() == 0)
    return;  // empty table.
  else {
    EventValueType highest_val = map_in.rbegin()->first;
    table_.resize(highest_val+1, NULL);
    std::map<EventValueType, EventMap*>::const_iterator iter = map_in.begin(), end = map_in.end();
    for (; iter != end; ++iter) {
      KALDI_ASSERT(iter->first >= 0 && iter->first <= highest_val);
      table_[iter->first] = iter->second;
    }
  }
}

TableEventMap() [3/3]

TableEventMap ( EventKeyType  key, const std::map< EventValueType, EventAnswerType > &  map_in  )

explicit

This initializer creates a ConstantEventMap for each value in the map.

Definition at line 339 of file event-map.cc.

References KALDI_ASSERT, and TableEventMap::table_.

                                                                                                   : key_(key) {
  if (map_in.size() == 0)
    return;  // empty table.
  else {
    EventValueType highest_val = map_in.rbegin()->first;
    table_.resize(highest_val+1, NULL);
    std::map<EventValueType, EventAnswerType>::const_iterator iter = map_in.begin(), end = map_in.end();
    for (; iter != end; ++iter) {
      KALDI_ASSERT(iter->first >= 0 && iter->first <= highest_val);
      table_[iter->first] = new ConstantEventMap(iter->second);
    }
  }
}

~TableEventMap()

virtual ~TableEventMap ( )

inlinevirtual

Definition at line 257 of file event-map.h.

References kaldi::DeletePointers().

                           {
    DeletePointers(&table_);
  }

Member Function Documentation

Copy()

virtual EventMap* Copy ( const std::vector< EventMap *> &  new_leaves ) const

inlinevirtual

Implements EventMap.

Definition at line 252 of file event-map.h.

References EventMap::Copy(), and rnnlm::i.

                                                                       {
    std::vector<EventMap*> new_table_(table_.size(), NULL);
    for (size_t i = 0;i<table_.size();i++) if (table_[i]) new_table_[i]=table_[i]->Copy(new_leaves);
    return new TableEventMap(key_, new_table_);
  }

GetChildren()

virtual void GetChildren ( std::vector< EventMap *> *  out ) const

inlinevirtual

Implements EventMap.

Definition at line 218 of file event-map.h.

References rnnlm::i.

                                                            {
    out->clear();
    for (size_t i = 0; i<table_.size(); i++)
      if (table_[i] != NULL) out->push_back(table_[i]);
  }

KALDI_DISALLOW_COPY_AND_ASSIGN()

KALDI_DISALLOW_COPY_AND_ASSIGN ( TableEventMap  )

private

Map()

virtual bool Map ( const EventType &  event, EventAnswerType *  ans  ) const

inlinevirtual

Implements EventMap.

Definition at line 209 of file event-map.h.

Referenced by kaldi::TestEventMap().

                                                                       {
    EventValueType tmp;   *ans = -1;  // means no answer
    if (Lookup(event, key_, &tmp) && tmp >= 0
       && tmp < (EventValueType)table_.size() && table_[tmp] != NULL) {
      return table_[tmp]->Map(event, ans);
    }
    return false;
  }

MapValues()

EventMap * MapValues ( const unordered_set< EventKeyType > &  keys_to_map, const unordered_map< EventValueType, EventValueType > &  value_map  ) const

virtual

Implements EventMap.

Definition at line 88 of file event-map.cc.

References KALDI_ASSERT, KALDI_ERR, and EventMap::MapValues().

                                                                         {
  std::vector<EventMap*> table;
  table.reserve(table_.size());
  EventValueType size = table_.size();
  for (EventValueType value = 0; value < size; value++) {
    if (table_[value] != NULL) {
      EventMap *this_map = table_[value]->MapValues(keys_to_map, value_map);
      EventValueType mapped_value;

      if (keys_to_map.count(key_) == 0) mapped_value = value;
      else {
        unordered_map<EventValueType,EventValueType>::const_iterator
            iter = value_map.find(value);
        if (iter == value_map.end()) {
          KALDI_ERR << "Could not map value " << value
                    << " for key " << key_;
        }
        mapped_value = iter->second;
      }
      KALDI_ASSERT(mapped_value >= 0);
      if (static_cast<EventValueType>(table.size()) <= mapped_value)
        table.resize(mapped_value + 1, NULL);
      if (table[mapped_value] != NULL)
        KALDI_ERR << "Multiple values map to the same point: this code cannot "
                  << "handle this case.";
      table[mapped_value] = this_map;
    }
  }
  return new TableEventMap(key_, table);
}

MultiMap()

virtual void MultiMap ( const EventType &  event, std::vector< EventAnswerType > *  ans  ) const

inlinevirtual

Implements EventMap.

Definition at line 224 of file event-map.h.

References rnnlm::i.

                                                                                       {
    EventValueType tmp;
    if (Lookup(event, key_, &tmp)) {
      if (tmp >= 0 && tmp < (EventValueType)table_.size() && table_[tmp] != NULL)
        return table_[tmp]->MultiMap(event, ans);
      // else no answers.
    } else {  // all answers are possible if no such key.
      for (size_t i = 0;i < table_.size();i++)
        if (table_[i] != NULL) table_[i]->MultiMap(event, ans);  // append.
    }
  }

Prune()

EventMap * Prune ( ) const

virtual

Implements EventMap.

Definition at line 71 of file event-map.cc.

References EventMap::Prune().

                                     {
  std::vector<EventMap*> table;
  table.reserve(table_.size());
  EventValueType size = table_.size();
  for (EventKeyType value = 0; value < size; value++) {
    if (table_[value] != NULL) {
      EventMap *pruned_map = table_[value]->Prune();
      if (pruned_map != NULL) {
        table.resize(value + 1, NULL);
        table[value] = pruned_map;
      }
    }
  }
  if (table.empty()) return NULL;
  else return new TableEventMap(key_, table);
}

Read()

TableEventMap * Read ( std::istream &  is, bool  binary  )

static

Definition at line 140 of file event-map.cc.

References kaldi::ExpectToken(), EventMap::Read(), and kaldi::ReadBasicType().

Referenced by EventMap::Read().

                                                              {
  ExpectToken(is, binary, "TE");
  EventKeyType key;
  ReadBasicType(is, binary, &key);
  uint32 size;
  ReadBasicType(is, binary, &size);
  std::vector<EventMap*> table(size);
  ExpectToken(is, binary, "(");
  for (size_t t = 0; t < size; t++) {
    // This Read function works for NULL pointers.
    table[t] = EventMap::Read(is, binary);
  }
  ExpectToken(is, binary, ")");
  return new TableEventMap(key, table);
}

Write()

void Write ( std::ostream &  os, bool  binary  )

virtual

Write to stream.

Implements EventMap.

Definition at line 122 of file event-map.cc.

References KALDI_ERR, EventMap::Write(), kaldi::WriteBasicType(), and kaldi::WriteToken().

                                                     {
  WriteToken(os, binary, "TE");
  WriteBasicType(os, binary, key_);
  uint32 size = table_.size();
  WriteBasicType(os, binary, size);
  WriteToken(os, binary, "(");
  for (size_t t = 0; t < size; t++) {
    // This Write function works for NULL pointers.
    EventMap::Write(os, binary, table_[t]);
  }
  WriteToken(os, binary, ")");
  if (!binary) os << '\n';
  if (os.fail()) {
    KALDI_ERR << "TableEventMap::Write(), could not write to stream.";
  }
}

Member Data Documentation

key_

EventKeyType key_

private

Definition at line 261 of file event-map.h.

table_

std::vector<EventMap*> table_

private

Definition at line 262 of file event-map.h.

Referenced by TableEventMap::TableEventMap().

---

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

• tree/event-map.h
• tree/event-map.cc