mirror of
https://github.com/moses-smt/mosesdecoder.git
synced 2024-12-28 14:32:38 +03:00
100 lines
2.8 KiB
C++
100 lines
2.8 KiB
C++
#pragma once
|
|
|
|
#include <vector>
|
|
|
|
namespace MosesTraining {
|
|
namespace Syntax {
|
|
|
|
// A basic k-ary tree with node values of type T. Each node has a vector of
|
|
// pointers to its children and a pointer to its parent (or 0 for the root).
|
|
//
|
|
// See the unit tests in tree_test.cc for examples of usage.
|
|
//
|
|
// Note: a Tree owns its children: it will delete them on destruction.
|
|
//
|
|
// Note: it's the user's responsibility to ensure that parent and child pointers
|
|
// are correctly set and maintained. A convenient(-ish) way of building a
|
|
// properly-connected tree is to add all the nodes as children of their
|
|
// respective parents (using the children() accessor) and then call
|
|
// SetParents() on the root at the end.
|
|
//
|
|
template<typename T>
|
|
class Tree {
|
|
public:
|
|
// Constructors
|
|
Tree()
|
|
: value_()
|
|
, children_()
|
|
, parent_(0) {}
|
|
|
|
Tree(const T &value)
|
|
: value_(value)
|
|
, children_()
|
|
, parent_(0) {}
|
|
|
|
// Destructor (deletes children)
|
|
~Tree();
|
|
|
|
// Access tree's value.
|
|
const T &value() const { return value_; }
|
|
T &value() { return value_; }
|
|
|
|
// Access tree's parent.
|
|
const Tree *parent() const { return parent_; }
|
|
Tree *&parent() { return parent_; }
|
|
|
|
// Access tree's children.
|
|
const std::vector<Tree *> &children() const { return children_; }
|
|
std::vector<Tree *> &children() { return children_; }
|
|
|
|
// Set the parent values for this subtree (excluding this node).
|
|
void SetParents();
|
|
|
|
// Leaf predicate.
|
|
bool IsLeaf() const { return children_.empty(); }
|
|
|
|
// Calculate the depth of this node within the tree (where the root has a
|
|
// depth of 0, root's children have a depth 1, etc).
|
|
std::size_t Depth() const;
|
|
|
|
// Iterators
|
|
//
|
|
// All iterators are forward iterators. Example use:
|
|
//
|
|
// const Tree<int> &root = GetMeATree();
|
|
// for (Tree<int>::ConstPreOrderIterator p(root);
|
|
// p != Tree<int>::ConstPreOrderIterator(); ++p) {
|
|
// std::cout << p->value() << "\n";
|
|
// }
|
|
|
|
private:
|
|
// Use templates to avoid code duplication between const and non-const
|
|
// iterators. V is the value type: either Tree<T> or const Tree<T>.
|
|
template<typename V> class PreOrderIter;
|
|
// template<typename V> class PostOrderIter; TODO
|
|
template<typename V> class LeafIter;
|
|
|
|
public:
|
|
// Pre-order iterators.
|
|
typedef PreOrderIter<Tree<T> > PreOrderIterator;
|
|
typedef PreOrderIter<const Tree<T> > ConstPreOrderIterator;
|
|
|
|
// Post-order iterators.
|
|
// typedef PostOrderIter<Tree<T> > PostOrderIterator; TODO
|
|
// typedef PostOrderIter<const Tree<T> > ConstPostOrderIterator; TODO
|
|
|
|
// Leaf iterators (left-to-right).
|
|
typedef LeafIter<Tree<T> > LeafIterator;
|
|
typedef LeafIter<const Tree<T> > ConstLeafIterator;
|
|
|
|
private:
|
|
T value_;
|
|
std::vector<Tree *> children_;
|
|
Tree *parent_;
|
|
};
|
|
|
|
} // namespace Syntax
|
|
} // namespace MosesTraining
|
|
|
|
#include "tree-inl.h"
|