albaVMEIterator.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaVMEIterator
 Authors: Marco Petrone
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef __albaVMEIterator_h
#define __albaVMEIterator_h
//----------------------------------------------------------------------------
// includes :
//----------------------------------------------------------------------------
#include "albaObject.h"
#include "albaVME.h"
#include "albaVector.h"
#include "albaEventBroadcaster.h"
 
template class ALBA_EXPORT albaVector<albaID>;
 
class ALBA_EXPORT albaVMEIterator : public albaObject
{
public:
  albaTypeMacro(albaVMEIterator,albaObject);
  
  albaVME * GetCurrentNode() {return m_CurrentNode;}
 
  albaVME * GetFirstNode() {this->GoToFirstNode(); return (m_TraversalDone)?NULL:this->GetCurrentNode();}
  albaVME * GetLastNode() {this->GoToLastNode(); return (m_TraversalDone)?NULL:this->GetCurrentNode();}
  albaVME * GetNextNode() {this->GoToNextNode(); return (m_TraversalDone)?NULL:this->GetCurrentNode();}
  albaVME * GetPreviousNode() {this->GoToPreviousNode(); return (m_TraversalDone)?NULL:this->GetCurrentNode();}
 
  virtual bool IsVisible(albaVME *node) { return node->IsVisible();}
 
  virtual void IgnoreVisibleToTraverse(bool ignore) {m_IgnoreVisibleToTraverse = ignore;};
 
  void SetRootNode(albaVME *root);
  
  void InitTraversal();
  
  int IsDoneWithTraversal() {return m_TraversalDone;}
  
  virtual int GoToNextNode();
  
  virtual int GoToPreviousNode();
  
  virtual int GoToFirstNode();
  
  virtual int GoToLastNode();
 
  void SetTraversalMode(int mode);
  int GetTraversalMode() { return m_TraversalMode;}
 
  void SetTraversalModeToPreOrder() {this->SetTraversalMode(PreOrder);}
  void SetTraversalModeToPostOrder() {this->SetTraversalMode(PostOrder);}
 
  //void SetTraversalModeToInOrder() {this->SetTraversalMode(InOrder);}
  
  enum traversalMode {PreOrder=0,PostOrder};
 
protected:
 
  albaVME *FindLeftMostLeaf(albaVME *node);
 
  albaVME *FindRightMostLeaf(albaVME *node);
 
  albaVMEIterator(albaVME *root=NULL);
  virtual ~albaVMEIterator();
 
  albaVME         *m_RootNode;
  albaVME         *m_CurrentNode;
  int             m_TraversalMode;
  int             m_TraversalDone;
  bool            m_IgnoreVisibleToTraverse;
 
  albaVector<albaID> m_CurrentIdx;
 
private:
  albaVMEIterator(const albaVMEIterator&) {} // Not implemented
  void operator=(const albaVMEIterator&) {} // Not implemented
};
 
#endif