SplitEventMap Class Reference

#include <event-map.h>

Inheritance diagram for SplitEventMap:

Collaboration diagram for SplitEventMap:

Public Member Functions
virtual bool	Map (const EventType &event, EventAnswerType *ans) const
virtual void	MultiMap (const EventType &event, std::vector< EventAnswerType > *ans) const
virtual void	GetChildren (std::vector< EventMap *> *out) const
virtual EventMap *	Copy (const std::vector< EventMap *> &new_leaves) const
virtual void	Write (std::ostream &os, bool binary)
	Write to stream. More...
virtual EventMap *	Prune () const
virtual EventMap *	MapValues (const unordered_set< EventKeyType > &keys_to_map, const unordered_map< EventValueType, EventValueType > &value_map) const
virtual	~SplitEventMap ()
	SplitEventMap (EventKeyType key, const std::vector< EventValueType > &yes_set, EventMap *yes, EventMap *no)
	This constructor takes ownership of the "yes" and "no" arguments. More...
Public Member Functions inherited from EventMap
EventMap *	Copy () const
virtual EventAnswerType	MaxResult () const
virtual	~EventMap ()

Static Public Member Functions
static SplitEventMap *	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
	SplitEventMap (EventKeyType key, const ConstIntegerSet< EventValueType > &yes_set, EventMap *yes, EventMap *no)
	This constructor used in the Copy() function. More...
void	Destroy ()
SplitEventMap &	operator= (const SplitEventMap &other)

Private Attributes
EventKeyType	key_
ConstIntegerSet< EventValueType >	yes_set_
EventMap *	yes_
EventMap *	no_

Detailed Description

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

Constructor & Destructor Documentation

~SplitEventMap()

virtual ~SplitEventMap ( )

inlinevirtual

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

{ Destroy(); }

SplitEventMap() [1/2]

SplitEventMap ( EventKeyType  key, const std::vector< EventValueType > &  yes_set, EventMap *  yes, EventMap *  no  )

inline

This constructor takes ownership of the "yes" and "no" arguments.

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

References kaldi::IsSorted(), KALDI_ASSERT, and KALDI_PARANOID_ASSERT.

                                            : key_(key), yes_set_(yes_set), yes_(yes), no_(no) {
    KALDI_PARANOID_ASSERT(IsSorted(yes_set));
    KALDI_ASSERT(yes_ != NULL && no_ != NULL);
  }

SplitEventMap() [2/2]

SplitEventMap ( EventKeyType  key, const ConstIntegerSet< EventValueType > &  yes_set, EventMap *  yes, EventMap *  no  )

inlineprivate

This constructor used in the Copy() function.

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

References KALDI_ASSERT.

                                            : key_(key), yes_set_(yes_set), yes_(yes), no_(no) {
    KALDI_ASSERT(yes_ != NULL && no_ != NULL);
  }

Member Function Documentation

Copy()

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

inlinevirtual

Implements EventMap.

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

                                                                       {
    return new SplitEventMap(key_, yes_set_, yes_->Copy(new_leaves), no_->Copy(new_leaves));
  }

Destroy()

void Destroy ( )

inlineprivate

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

                 {
    delete yes_; delete no_;
  }

GetChildren()

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

inlinevirtual

Implements EventMap.

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

                                                            {
    out->clear();
    out->push_back(yes_);
    out->push_back(no_);
  }

Map()

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

inlinevirtual

Implements EventMap.

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

                                                                       {
    EventValueType value;
    if (Lookup(event, key_, &value)) {
      // if (std::binary_search(yes_set_.begin(), yes_set_.end(), value)) {
      if (yes_set_.count(value)) {
        return yes_->Map(event, ans);
      }
      return no_->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 165 of file event-map.cc.

References ConstIntegerSet< I >::begin(), KALDI_ERR, EventMap::MapValues(), and kaldi::SortAndUniq().

                                                                         {
  EventMap *yes = yes_->MapValues(keys_to_map, value_map),
      *no = no_->MapValues(keys_to_map, value_map);

  if (keys_to_map.count(key_) == 0) {
    return new SplitEventMap(key_, yes_set_, yes, no);
  } else {
    std::vector<EventValueType> yes_set;
    for (ConstIntegerSet<EventValueType>::iterator iter = yes_set_.begin();
         iter != yes_set_.end();
         ++iter) {
      EventValueType value = *iter;
      unordered_map<EventValueType, EventValueType>::const_iterator
          map_iter = value_map.find(value);
      if (map_iter == value_map.end())
        KALDI_ERR << "Value " << value << ", for key "
                  << key_ << ", cannot be mapped.";
      EventValueType mapped_value = map_iter->second;
      yes_set.push_back(mapped_value);
    }
    SortAndUniq(&yes_set);
    return new SplitEventMap(key_, yes_set, yes, no);
  }  
}

MultiMap()

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

inlinevirtual

Implements EventMap.

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

                                                                                       {
    EventValueType tmp;
    if (Lookup(event, key_, &tmp)) {
      if (std::binary_search(yes_set_.begin(), yes_set_.end(), tmp))
        yes_->MultiMap(event, ans);
      else
        no_->MultiMap(event, ans);
    } else {  // both yes and no contribute.
      yes_->MultiMap(event, ans);
      no_->MultiMap(event, ans);
    }
  }

operator=()

SplitEventMap& operator= ( const SplitEventMap &  other )

private

Prune()

EventMap * Prune ( ) const

virtual

Implements EventMap.

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

References EventMap::Prune().

                                     {
  EventMap *yes = yes_->Prune(),
      *no = no_->Prune();
  if (yes == NULL && no == NULL) return NULL;
  else if (yes == NULL) return no;
  else if (no == NULL) return yes;
  else return new SplitEventMap(key_, yes_set_, yes, no);
}

Read()

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

static

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

References kaldi::ExpectToken(), KALDI_ERR, ConstIntegerSet< I >::Read(), EventMap::Read(), and kaldi::ReadBasicType().

Referenced by EventMap::Read().

                                                              {
  ExpectToken(is, binary, "SE");
  EventKeyType key;
  ReadBasicType(is, binary, &key);
  // std::vector<EventValueType> yes_set;
  // ReadIntegerVector(is, binary, &yes_set);
  ConstIntegerSet<EventValueType> yes_set;
  yes_set.Read(is, binary);
  ExpectToken(is, binary, "{");
  EventMap *yes = EventMap::Read(is, binary);
  EventMap *no = EventMap::Read(is, binary);
  ExpectToken(is, binary, "}");
  // yes and no should be non-NULL because NULL values are not valid for SplitEventMap;
  // the constructor checks this.  Therefore this is an unlikely error.
  if (yes == NULL || no == NULL) KALDI_ERR << "SplitEventMap::Read, NULL pointers.";
  return new SplitEventMap(key, yes_set, yes, no);
}

Write()

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

virtual

Write to stream.

Implements EventMap.

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

References KALDI_ASSERT, KALDI_ERR, kaldi::WriteBasicType(), and kaldi::WriteToken().

                                                     {
  WriteToken(os, binary, "SE");
  WriteBasicType(os, binary, key_);
  // WriteIntegerVector(os, binary, yes_set_);
  yes_set_.Write(os, binary);
  KALDI_ASSERT(yes_ != NULL && no_ != NULL);
  WriteToken(os, binary, "{");
  yes_->Write(os, binary);
  no_->Write(os, binary);
  WriteToken(os, binary, "}");
  if (!binary) os << '\n';
  if (os.fail()) {
    KALDI_ERR << "SplitEventMap::Write(), could not write to stream.";
  }
}

Member Data Documentation

key_

EventKeyType key_

private

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

no_

EventMap* no_

private

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

yes_

EventMap* yes_

private

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

yes_set_

ConstIntegerSet<EventValueType> yes_set_

private

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

---

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

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