model.h

Go to the documentation of this file.

/*
 *  model.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 MODEL_H
#define MODEL_H
#include <string>

#include <new>
#include <vector>
#include "node.h"
#include "allocator.h"
#include "dictutils.h"

namespace nest
{

  class Model
  {
  public:

      Model(const std::string& name);
      Model(const Model& m):
      name_(m.name_),
      type_id_(m.type_id_),
      memory_(m.memory_)
      {}
    
      virtual ~Model(){}

    virtual Model* clone(const std::string&) const =0;

    void set_threads();

    Node* allocate(thread t);

    void  free(thread t, Node *);

    void clear();

    void  reserve_additional(thread t, size_t n);

    std::string get_name() const;

    size_t mem_available();

    size_t mem_capacity();

    virtual bool has_proxies()=0;
    virtual bool potential_global_receiver()=0;
    virtual bool one_node_per_process()=0;
    virtual bool is_off_grid()=0;
 
    void set_status(DictionaryDatum);

    DictionaryDatum get_status(void) ;

    virtual port send_test_event(Node&, rport, synindex, bool)=0;

    virtual 
    size_t get_element_size() const=0;

    virtual 
    Node const& get_prototype(void) const =0;

    virtual
    void set_model_id(int) =0;
    
    void set_type_id(index id)
    {
      type_id_=id;
    }
      
    index get_type_id() const
    {
      return type_id_;
    }
          
  private:
  
    virtual 
    void set_status_(DictionaryDatum)=0;

    virtual 
    DictionaryDatum get_status_()=0;


    void set_threads_(thread t);
  
    virtual
    void init_memory_(sli::pool &)=0;

    virtual
    Node * allocate_(void *)=0;

    std::string name_;

    index type_id_; 

    std::vector<sli::pool> memory_;

  };


  inline
  Node * Model::allocate(thread t)
  {
    assert((size_t)t < memory_.size());
    return allocate_(memory_[t].alloc());
  }

  inline
  void Model::free(thread t, Node *n)
  {
    assert((size_t)t < memory_.size());
    memory_[t].free(n);
  }

  inline
  std::string Model::get_name() const
  {
    return name_;
  }

}
#endif