fsfw/container/BinaryTree.h

#ifndef FRAMEWORK_CONTAINER_BINARYTREE_H_
#define FRAMEWORK_CONTAINER_BINARYTREE_H_

#include <stddef.h>
#include <stdint.h>
#include <map>
template<typename Tp>
class BinaryNode {
public:
	BinaryNode(Tp* setValue) :
			value(setValue), left(NULL), right(NULL), parent(NULL) {
	}
	Tp *value;
	BinaryNode* left;
	BinaryNode* right;
	BinaryNode* parent;
};

template<typename Tp>
class ExplicitNodeIterator {
public:
	typedef ExplicitNodeIterator<Tp> _Self;
	typedef BinaryNode<Tp> _Node;
	typedef Tp value_type;
	typedef Tp* pointer;
	typedef Tp& reference;
	ExplicitNodeIterator() :
			element(NULL) {
	}
	ExplicitNodeIterator(_Node* node) :
			element(node) {
	}
	BinaryNode<Tp>* element;
	_Self up() {
		return _Self(element->parent);
	}
	_Self left() {
		if (element != NULL) {
			return _Self(element->left);
		} else {
			return _Self(NULL);
		}

	}
	_Self right() {
		if (element != NULL) {
			return _Self(element->right);
		} else {
			return _Self(NULL);
		}

	}
	bool operator==(const _Self& __x) const {
		return element == __x.element;
	}
	bool operator!=(const _Self& __x) const {
		return element != __x.element;
	}
    pointer
    operator->() const {
    	if (element != NULL) {
    		return element->value;
    	} else {
    		return NULL;
    	}
    }
    pointer operator*() const {
    	return this->operator->();
    }
};

/**
 * Pretty rudimentary version of a simple binary tree (not a binary search tree!).
 */
template<typename Tp>
class BinaryTree {
public:
	typedef ExplicitNodeIterator<Tp> iterator;
	typedef BinaryNode<Tp> Node;
	typedef std::pair<iterator, iterator> children;
	BinaryTree() :
			rootNode(NULL) {
	}
	BinaryTree(Node* rootNode) :
			rootNode(rootNode) {
	}
	iterator begin() const {
		return iterator(rootNode);
	}
	static iterator end() {
		return iterator(NULL);
	}
	iterator insert(bool insertLeft, iterator parentNode, Node* newNode ) {
		newNode->parent = parentNode.element;
		if (parentNode.element != NULL) {
			if (insertLeft) {
				parentNode.element->left = newNode;
			} else {
				parentNode.element->right = newNode;
			}
		} else {
			//Insert first element.
			rootNode = newNode;
		}
		return iterator(newNode);
	}
	//No recursion to children. Needs to be done externally.
	children erase(iterator node) {
		if (node.element == rootNode) {
			//We're root node
			rootNode = NULL;
		} else {
			//Delete parent's reference
			if (node.up().left() == node) {
				node.up().element->left = NULL;
			} else {
				node.up().element->right = NULL;
			}
		}
		return children(node.element->left, node.element->right);
	}
	static uint32_t countLeft(iterator start) {
		if (start == end()) {
			return 0;
		}
		//We also count the start node itself.
		uint32_t count = 1;
		while (start.left() != end()) {
			count++;
			start = start.left();
		}
		return count;
	}
	static uint32_t countRight(iterator start) {
		if (start == end()) {
			return 0;
		}
		//We also count the start node itself.
		uint32_t count = 1;
		while (start.right() != end()) {
			count++;
			start = start.right();
		}
		return count;
	}

protected:
	Node* rootNode;
};



#endif /* FRAMEWORK_CONTAINER_BINARYTREE_H_ */