nodelist.h

Go to the documentation of this file.

/*
 *  nodelist.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST 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.
 *
 *  NEST 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 NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef NODELIST_H
#define NODELIST_H

#include "node.h"
#include "subnet.h"

namespace nest{

template <typename ListIterator>
class LocalNodeListBase
{
public:
  typedef ListIterator iterator;

  explicit LocalNodeListBase(Subnet &subnet) : subnet_(subnet) {}

  iterator begin() const;

  iterator end() const { return iterator(subnet_.local_end(),
                                         subnet_.local_end()); }

  bool empty() const { return subnet_.local_empty(); }

  Subnet& get_subnet() const { return subnet_; }

private:
  Subnet& subnet_;  
};


// ----------------------------------------------------------------------------

class LocalNodeListIterator
{
  friend class LocalNodeListBase<LocalNodeListIterator>;
  friend class LocalLeafListIterator;

  private:
   LocalNodeListIterator(std::vector<Node*>::iterator const &node,
                         std::vector<Node*>::iterator const &list_end) :
      current_node_(node), list_end_(list_end) {}
   bool is_end_() const { return current_node_ == list_end_; }

 public:
   LocalNodeListIterator operator++();

   Node*        operator*() { return *current_node_; }
   Node const*  operator*() const { return *current_node_; }

   bool operator==(const LocalNodeListIterator& i) const { return current_node_ == i.current_node_; }
   bool operator!=(const LocalNodeListIterator& i) const { return not ( *this == i ); }

 private:
   vector<Node *>::iterator current_node_;
   vector<Node *>::iterator list_end_;

};


// ----------------------------------------------------------------------------

template <>
  LocalNodeListBase<LocalNodeListIterator>::iterator
  LocalNodeListBase<LocalNodeListIterator>::begin() const;

typedef LocalNodeListBase<LocalNodeListIterator> LocalNodeList;

// ----------------------------------------------------------------------------

class LocalChildListIterator
{
  friend class LocalNodeListBase<LocalChildListIterator>;

  private:
   LocalChildListIterator(std::vector<Node*>::iterator const &node,
                          std::vector<Node*>::iterator const &list_end) :
     current_node_(node), list_end_(list_end) {}

 public:
   LocalChildListIterator operator++();

   Node*        operator*() { return *current_node_; }
   Node const*  operator*() const { return *current_node_; }

   bool operator==(const LocalChildListIterator& i) const { return current_node_ == i.current_node_; }
   bool operator!=(const LocalChildListIterator& i) const { return not ( *this == i ); }

 private:
   vector<Node *>::iterator current_node_;
   vector<Node *>::iterator list_end_;
};

template <> 
  LocalNodeListBase<LocalChildListIterator>::iterator
  LocalNodeListBase<LocalChildListIterator>::begin() const;

typedef LocalNodeListBase<LocalChildListIterator> LocalChildList;

// ----------------------------------------------------------------------------

class LocalLeafListIterator
{
  friend class LocalNodeListBase<LocalLeafListIterator>;

  private:
   LocalLeafListIterator(std::vector<Node*>::iterator const &node,
                          std::vector<Node*>::iterator const &list_end) :
     base_it_(node, list_end)
   {
     while ( not base_it_.is_end_() && not is_leaf_(*base_it_) )
       ++base_it_;
   }

 public:
   LocalLeafListIterator operator++();

   Node*        operator*() { return *base_it_; }
   Node const*  operator*() const { return *base_it_; }

   bool operator==(const LocalLeafListIterator& i) const { return base_it_ == i.base_it_; }
   bool operator!=(const LocalLeafListIterator& i) const { return not ( *this == i ); }

 private:
   LocalNodeListIterator base_it_;  //<! we use this one for the basic iteration

   static bool is_leaf_(Node *n)  { return not dynamic_cast<Subnet*>(n); }

};

template <>
  LocalNodeListBase<LocalLeafListIterator>::iterator
  LocalNodeListBase<LocalLeafListIterator>::begin() const;

typedef LocalNodeListBase<LocalLeafListIterator> LocalLeafList;

}
#endif