if (emap == NULL) {

WriteToken(os, binary, "NULL");

} else {

emap->Write(os, binary);

}

WriteToken(os, binary, "CE");

WriteBasicType(os, binary, answer_);

if (os.fail()) {

KALDI_ERR << "ConstantEventMap::Write(), could not write to stream.";

}

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.";

}

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.";

}

WriteToken(os, binary, "EV");

uint32 size = evec.size();

WriteBasicType(os, binary, size);

for (size_t i = 0; i < size; i++) {

WriteBasicType(os, binary, evec[i].first);

WriteBasicType(os, binary, evec[i].second);

}

if (!binary) os << '\n';

KALDI_ASSERT(evec != NULL);

ExpectToken(is, binary, "EV");

uint32 size;

ReadBasicType(is, binary, &size);

evec->resize(size);

for (size_t i = 0; i < size; i++) {

ReadBasicType(is, binary, &( (*evec)[i].first ));

ReadBasicType(is, binary, &( (*evec)[i].second ));

}

std::stringstream ss;

EventType::const_iterator iter = evec.begin(), end = evec.end();

std::string sep = "";

for (; iter != end; ++iter) {

ss << sep << iter->first <<":"<<iter->second;

sep = " ";

}

return ss.str();

// will crash if not sorted or has duplicates

size_t sz = event.size();

for (size_t i = 0;i+1 < sz;i++)

KALDI_ASSERT(event[i].first < event[i+1].first);

EventKeyType key, EventValueType *ans) {

// this assumes that the "event" array is sorted (e.g. on the KeyType value;

// just doing std::sort will do this) and has no duplicate values with the same

// key. call Check() to verify this.

#ifdef KALDI_PARANOID

Check(event);

#endif

std::vector<std::pair<EventKeyType, EventValueType> >::const_iterator

begin = event.begin(),

end = event.end(),

middle; // "middle" is used as a temporary variable in the algorithm.

// begin and sz store the current region where the first instance of

// "value" might appear.

// This is like this stl algorithm "lower_bound".

size_t sz = end-begin, half;

while (sz > 0) {

half = sz >> 1;

middle = begin + half; // "end" here is now reallly the middle.

if (middle->first < key) {

begin = middle;

++begin;

sz = sz - half - 1;

} else {

sz = half;

}

}

if (begin != end && begin->first == key) {

*ans = begin->second;

return true;

} else {

return false;

}

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;

}

}

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);

}

}

std::vector<EventMap*> children;

e->GetChildren(&children);

return children.empty();

const EventMap &map,

std::vector<const EventMap*> *nonleaf_nodes,

std::map<const EventMap*, const EventMap*> *nonleaf_parents,

std::vector<const EventMap*> *leaf_parents) {

std::vector<const EventMap*> queue; // parents to be processed.

const EventMap *top_node = &map;

queue.push_back(top_node);

nonleaf_nodes->push_back(top_node);

(*nonleaf_parents)[top_node] = top_node;

while (!queue.empty()) {

const EventMap *parent = queue.back();

queue.pop_back();

std::vector<EventMap*> children;

parent->GetChildren(&children);

KALDI_ASSERT(!children.empty());

for (size_t i = 0; i < children.size(); i++) {

EventMap *child = children[i];

if (IsLeafNode(child)) {

int32 leaf;

if (!child->Map(EventType(), &leaf)

|| leaf < 0) return false;

if (static_cast<int32>(leaf_parents->size()) <= leaf)

leaf_parents->resize(leaf+1, NULL);

if ((*leaf_parents)[leaf] != NULL) {

KALDI_WARN << "Repeated leaf! Did you suppress leaf clustering when building the tree?";

return false; // repeated leaf.

}

(*leaf_parents)[leaf] = parent;

} else {

nonleaf_nodes->push_back(child);

(*nonleaf_parents)[child] = parent;

queue.push_back(child);

}

}

}

for (size_t i = 0; i < leaf_parents->size(); i++)

if ((*leaf_parents)[i] == NULL) {

KALDI_WARN << "non-consecutively numbered leaves";

return false;

}

// non-consecutively numbered leaves.

KALDI_ASSERT(!leaf_parents->empty()); // or no leaves.

return true;

int32 *num_leaves,

std::vector<int32> *parents) {

KALDI_ASSERT (num_leaves != NULL && parents != NULL);

if (IsLeafNode(&map)) { // handle degenerate case where root is a leaf.

int32 leaf;

if (!map.Map(EventType(), &leaf)

|| leaf != 0) return false;

*num_leaves = 1;

parents->resize(1);

(*parents)[0] = 0;

return true;

}

// This vector gives the address of nonleaf nodes in the tree,

// in a numbering where 0 is the root and children always come

// after parents.

std::vector<const EventMap*> nonleaf_nodes;

// Map from each nonleaf node to its parent node

// (or to itself for the root node).

std::map<const EventMap*, const EventMap*> nonleaf_parents;

// Map from leaf nodes to their parent nodes.

std::vector<const EventMap*> leaf_parents;

if (!GetTreeStructureInternal(map, &nonleaf_nodes,

&nonleaf_parents,

&leaf_parents)) return false;

*num_leaves = leaf_parents.size();

int32 num_nodes = leaf_parents.size() + nonleaf_nodes.size();

std::map<const EventMap*, int32> nonleaf_indices;

// number the nonleaf indices so they come after the leaf

// indices and the root is last.

for (size_t i = 0; i < nonleaf_nodes.size(); i++)

nonleaf_indices[nonleaf_nodes[i]] = num_nodes - i - 1;

parents->resize(num_nodes);

for (size_t i = 0; i < leaf_parents.size(); i++) {

KALDI_ASSERT(nonleaf_indices.count(leaf_parents[i]) != 0);

(*parents)[i] = nonleaf_indices[leaf_parents[i]];

}

for (size_t i = 0; i < nonleaf_nodes.size(); i++) {

KALDI_ASSERT(nonleaf_indices.count(nonleaf_nodes[i]) != 0);

KALDI_ASSERT(nonleaf_parents.count(nonleaf_nodes[i]) != 0);

KALDI_ASSERT(nonleaf_indices.count(nonleaf_parents[nonleaf_nodes[i]]) != 0);

int32 index = nonleaf_indices[nonleaf_nodes[i]],

parent_index = nonleaf_indices[nonleaf_parents[nonleaf_nodes[i]]];

KALDI_ASSERT(index > 0 && parent_index >= index);

(*parents)[index] = parent_index;

}

for (int32 i = 0; i < num_nodes; i++)

KALDI_ASSERT ((*parents)[i] > i || (i+1==num_nodes && (*parents)[i] == i));

return true;