genericmodel.h

Go to the documentation of this file.

/*
 *  genericmodel.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 GENERICMODEL_H
#define GENERICMODEL_H

#include "model.h"
#include "dynmodule.h"
#include <new>

namespace nest
{
  template <typename ElementT>
  class GenericModel: public Model
  {
  public:
    GenericModel(const std::string &);
    GenericModel(const char[]);

    GenericModel(const GenericModel&, const std::string&);

    Model* clone(const std::string&) const;

    bool has_proxies();
    bool potential_global_receiver();
    bool one_node_per_process();
    bool is_off_grid();
    port send_test_event(Node&, rport, synindex, bool);

    Node const & get_prototype() const;

    void set_model_id(int);

  private:

    void set_status_(DictionaryDatum);
    DictionaryDatum get_status_();

    size_t get_element_size() const;

    Node* allocate_(void *);

    void init_memory_(sli::pool &);

    ElementT proto_;
  };

  template< typename ElementT>
  GenericModel<ElementT>::GenericModel(const std::string &name)
    : Model(name),
      proto_()
  {
    set_threads();
  }

  template< typename ElementT>
  GenericModel<ElementT>::GenericModel(const char name[])
    : Model(std::string(name)),
      proto_()
  {
    set_threads();
  }

  template <typename ElementT>
  GenericModel<ElementT>::GenericModel(const GenericModel& oldmod, 
                       const std::string& newname)
    : Model(newname),
      proto_(oldmod.proto_)
  {
    set_type_id(oldmod.get_type_id());
    set_threads();
  }

  template <typename ElementT>
  Model* GenericModel<ElementT>::clone(const std::string& newname) const
  {
    return new GenericModel(*this, newname);
  }

  template< typename ElementT>
  Node* GenericModel<ElementT>::allocate_(void *adr)
  {
    Node *n = new(adr) ElementT(proto_);
    return n;
  }

  template< typename ElementT>
  void GenericModel<ElementT>::init_memory_(sli::pool &mem)
  {
    mem.init(sizeof(ElementT), 1000, 1);
  }

  template <typename ElementT>
  inline
  bool GenericModel<ElementT>::has_proxies()
  {
    return proto_.has_proxies();
  }
  
  template <typename ElementT>
  inline
  bool GenericModel<ElementT>::potential_global_receiver()
  {
    return proto_.potential_global_receiver();
  }

  template <typename ElementT>
  inline
  bool GenericModel<ElementT>::one_node_per_process()
  {
    return proto_.one_node_per_process();
  }

  template <typename ElementT>
  inline
  bool GenericModel<ElementT>::is_off_grid()
  {
    return proto_.is_off_grid();
  }

  template <typename ElementT>
  inline
  port GenericModel<ElementT>::send_test_event(Node& target, rport receptor, synindex syn_id, bool dummy_target)
  {
    return proto_.send_test_event(target, receptor, syn_id, dummy_target);
  }

  template <typename ElementT>
  void GenericModel<ElementT>::set_status_(DictionaryDatum d)
  {
    proto_.set_status(d);
  }

  template <typename ElementT>
  DictionaryDatum GenericModel<ElementT>::get_status_()
  {
    DictionaryDatum d = proto_.get_status_base();
    (*d)["elementsize"]= sizeof(ElementT);
    return d;
  }

  template <typename ElementT>
  size_t GenericModel<ElementT>::get_element_size() const
  {
    return sizeof(ElementT);
  }
  
  template <typename ElementT>
  Node const & GenericModel<ElementT>::get_prototype() const
  {
    return proto_;
  }

  template <typename ElementT>
  void GenericModel<ElementT>::set_model_id(int i)
  {
    proto_.set_model_id(i);
  }
  
      
  template <class ModelT>
  index register_model(Network& net, const std::string &name, 
                      bool private_model = false)
  {
    Model* prototype = new GenericModel<ModelT>(name);
    assert(prototype != 0);
    return net.register_model(*prototype, private_model);
  }

  template <class ModelT>
  index register_preconf_model(Network& net, const std::string &name, 
                   Dictionary& conf, bool private_model = false)
  {
    Model* prototype = new GenericModel<ModelT>(name);
    assert(prototype != 0);
    conf.clear_access_flags();
    prototype->set_status(conf);
    std::string missed;
    assert(conf.all_accessed(missed));  // we only get here from C++ code, no need for exception
    return net.register_model(*prototype, private_model);
  }
   
  template <class ModelT>
  index register_private_model(Network& net, const std::string &name)
  {
    return register_model<ModelT>(net, name, true);
  }
}
#endif