sparse_node_array.h

Go to the documentation of this file.

/*
 *  sparse_node_array.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 SPARSE_NODE_ARRAY_H
#define SPARSE_NODE_ARRAY_H

#include <cassert>
#include <vector>
#include <map>

#include "nest.h"

namespace nest {
  class Node;

class SparseNodeArray
{
private:

  struct NodeEntry_ {
    NodeEntry_(Node&, index);
    Node* node_;
    index gid_;  
  };

public:
  SparseNodeArray();

  size_t size() const;

  void reserve(size_t);

  void clear();

  size_t max_size() const;

  void add_local_node(Node&);

  void add_remote_node(index);

  Node* get_node_by_gid(index) const;

  Node* get_node_by_index(size_t) const;

  index get_max_gid() const;

  std::map<long, size_t> get_step_ctr() const;

private:
  std::vector<NodeEntry_> nodes_;   
  index                   max_gid_; 
  index                   local_min_gid_; 
  index                   local_max_gid_; 
  double                  gid_idx_scale_; 
  mutable std::map<long, size_t>  step_ctr_; 
};

}  // namespace nest

inline
size_t nest::SparseNodeArray::size() const
{
    return nodes_.size();
}

inline
void nest::SparseNodeArray::clear()
{
    nodes_.clear();
    max_gid_ = 0;
    local_min_gid_ = 0;
    local_max_gid_ = 0;
    gid_idx_scale_ = 1.;
    step_ctr_.clear();
}

inline
size_t nest::SparseNodeArray::max_size() const
{
    return nodes_.max_size();
}

inline
nest::Node* nest::SparseNodeArray::get_node_by_index(size_t idx) const
{
  assert(idx < nodes_.size());
  return nodes_[idx].node_;
}

inline
nest::index nest::SparseNodeArray::get_max_gid() const
{
    return max_gid_;
}

inline
std::map<long, size_t> nest::SparseNodeArray::get_step_ctr() const
{
    return step_ctr_;
}

#endif /* SPARSE_NODE_ARRAY_H */