base.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef GRAPH_TREE_BASE_H
#define GRAPH_TREE_BASE_H
 
 
//--- header files ------------------------------------------------------------
 
#include <graph/config/graph_config.h>
#include <list>
#include <algorithm>
 
 
//--- class declarations ------------------------------------------------------

class GRAPH_API BaseTree
{
public:
  typedef std::list<BaseTree *>::iterator               iterator;
  typedef std::list<BaseTree *>::const_iterator         const_iterator;
  typedef std::list<BaseTree *>::reverse_iterator       reverse_iterator;
  typedef std::list<BaseTree *>::const_reverse_iterator const_reverse_iterator;

  BaseTree( bool allowsChildren = true );
  virtual ~BaseTree();
 
  const std::list<BaseTree *> & children() const;
  bool getAllowsChildren() const;
  BaseTree* getChildAt( unsigned childIndex ) const;
  int getIndex( BaseTree* node ) const;
  BaseTree* getParent() const;
  BaseTree* getTopParent();
  const BaseTree* getTopParent() const;
  bool isLeaf() const;

  void insert( BaseTree* child, int index=-1 );
  void remove( unsigned index );
  void remove( BaseTree* node );
  void removeFromParent();
  void setParent( BaseTree* newParent );
  void clear();


  virtual size_t size() const
    __attribute__((__deprecated__("use childrenSize() for the number of children")));
  virtual size_t childrenSize() const;
  const_iterator begin() const;
  const_iterator end() const;
  const_reverse_iterator rbegin() const;
  const_reverse_iterator rend() const;
 
protected:
 
private:
  bool                  _allowsChildren;
  BaseTree              *_parent;
  std::list<BaseTree *>      _children;
};
 
 
//--- inline methods ----------------------------------------------------------
 
inline BaseTree::BaseTree( bool allowsChildren )
  : _allowsChildren( allowsChildren ), _parent( 0 )
{
}
 
 
inline bool BaseTree::getAllowsChildren() const
{
  return _allowsChildren;
}
 
 
inline BaseTree* BaseTree::getChildAt( unsigned childIndex ) const
{
  const_iterator  it;
  unsigned              i;
 
  for( i=0, it=_children.begin(); i<childIndex && it!=_children.end(); 
       ++it, ++i ) {}
  if( it != _children.end() ) return *it;
  else return 0;
}
 
 
inline size_t BaseTree::size() const
{
  return _children.size();
}
 
 
inline size_t BaseTree::childrenSize() const
{
  return _children.size();
}
 
 
inline BaseTree* BaseTree::getParent() const
{
  return _parent;
}
 
 
inline bool BaseTree::isLeaf() const
{
  return _children.size() == 0;
}
 
 
inline BaseTree::const_iterator BaseTree::begin() const
{
  return _children.begin();
}
 
 
inline BaseTree::const_iterator BaseTree::end() const
{
  return _children.end();
}
 
 
inline BaseTree::const_reverse_iterator BaseTree::rbegin() const
{
  return _children.rbegin();
}
 
 
inline BaseTree::const_reverse_iterator BaseTree::rend() const
{
  return _children.rend();
}
 
 
inline void BaseTree::removeFromParent()
{
  if( getParent() ) getParent()->remove( this );
  setParent( 0 );
}
 
 
inline void BaseTree::setParent( BaseTree* newParent )
{
  _parent = newParent;
}
 
 
#endif