First commit of PhyloMOEO files with some additions to Paradiseo-MOEO

git-svn-id: svn://scm.gforge.inria.fr/svnroot/paradiseo@1335 331e1502-861f-0410-8da2-ba01fb791d7f

contribution/branches/PhyloMOEA/PhyloMOEA/treeIterator.h

@@ -0,0 +1,104 @@
+/***************************************************************************
+ *   Copyright (C) 2005 by Waldo Cancino                                   *
+ *   wcancino@icmc.usp.br                                                  *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+
+#ifndef _treeIterator_H_
+#define _treeIterator_H_
+
+#include <list>
+#include <GTL/graph.h>
+
+
+typedef pair<node, node::inout_edges_iterator> stack_info;
+// Virtual Base Class for Pre-Order and Post-Order iterators
+class treeIterator
+{
+	protected:
+		node invalid_node; // points to the virtual root
+		node root;		// root of the tree (subtree)
+		node father;		// father of the root (tree or subtree)
+		node curnode;		// current node
+		node curfather;	// father of the current node
+		// stack saves the father nodes and the iterator position for the
+		// current node (child of father)
+		node::inout_edges_iterator current_it;
+	
+		list< stack_info > pilha;
+	public:
+		// constructor for an sub-tree pre-order traversal
+		treeIterator(node r, node f): root(r), father(f) {};
+		// constructor for a tree pre-order traversal father = invalid_node
+		treeIterator(node r): root(r), father(invalid_node) {};
+		virtual ~treeIterator() {};
+		// compare two iterators
+		inline bool operator!=(treeIterator &other)
+		{	
+			return curnode != other.curnode;
+		}
+		inline void last_node() { pilha.clear(); curnode = curfather = father; }
+		// pointer operator
+		inline node * operator->() { return &curnode; }
+		// dereference operator
+		inline node & operator*() { return curnode; }
+		// ancestor of the current_node
+		inline node ancestor() { return curfather; }
+		// branch with endpoints (curnode, curfather)
+		inline edge branch() { return *(pilha.back().second); }
+		// size of the stack
+		inline int stack_size() { return pilha.size(); }
+		// point to the first child of curnode
+		node::inout_edges_iterator& first_valid_edge();
+		// point to the next child of curnode
+		node::inout_edges_iterator& next_valid_edge();
+		// defined in derived classes
+		virtual void first_node() = 0;
+};
+
+class child_Iterator: public treeIterator
+{
+	public:
+		child_Iterator(node r, node f):treeIterator(r,f) {};
+		child_Iterator(node r):treeIterator(r) {};
+		child_Iterator& operator++();
+		void first_node();
+		edge branch() { return *current_it; };
+		virtual ~child_Iterator() {};
+};
+
+class postorder_Iterator: public treeIterator
+{
+	public:
+		postorder_Iterator(node r, node f):treeIterator(r,f) {};
+		postorder_Iterator(node r):treeIterator(r) {};
+		postorder_Iterator& operator++();
+		void first_node();
+		virtual ~postorder_Iterator() {};
+};
+
+class preorder_Iterator: public treeIterator
+{
+	public:
+		preorder_Iterator(node r, node f): treeIterator(r,f) {};
+		preorder_Iterator(node r):treeIterator(r)  {};
+		preorder_Iterator& operator++();
+		void first_node();
+		virtual ~preorder_Iterator() {};
+};
+
+#endif