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
 
// C++ includes:
#include <new>
#include <string>
#include <vector>
 
// Includes from nestkernel:
#include "node.h"
 
 
namespace nest
{
class TimeConverter;
 
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* create( size_t t );
 
  void clear();
 
  void reserve_additional( size_t t, size_t n );
 
  std::string get_name() const;
 
  size_t mem_available();
 
  size_t mem_capacity();
 
  virtual bool has_proxies() = 0;
  virtual bool local_receiver() = 0;
  virtual bool one_node_per_process() = 0;
  virtual bool is_off_grid() = 0;
  virtual void calibrate_time( const TimeConverter& tc ) = 0;
 
  void set_status( const Dictionary& );
 
  Dictionary get_status();
 
  virtual size_t send_test_event( Node&, size_t, synindex, bool ) = 0;
 
  virtual void sends_secondary_event( GapJunctionEvent& ge ) = 0;
  virtual void sends_secondary_event( InstantaneousRateConnectionEvent& re ) = 0;
  virtual void sends_secondary_event( DiffusionConnectionEvent& de ) = 0;
  virtual void sends_secondary_event( DelayedRateConnectionEvent& re ) = 0;
  virtual void sends_secondary_event( LearningSignalConnectionEvent& re ) = 0;
  virtual void sends_secondary_event( SICEvent& sic ) = 0;
 
  virtual SignalType sends_signal() const = 0;
 
  virtual size_t get_element_size() const = 0;
 
  virtual Node const& get_prototype() const = 0;
 
  virtual void set_model_id( int ) = 0;
 
  virtual int get_model_id() = 0;
 
  virtual void deprecation_warning( const std::string& ) = 0;
 
  void
  set_type_id( size_t id )
  {
    type_id_ = id;
  }
 
  size_t
  get_type_id() const
  {
    return type_id_;
  }
 
private:
  virtual void set_status_( const Dictionary& ) = 0;
 
  virtual Dictionary get_status_() = 0;
 
 
  void set_threads_( size_t t );
 
  virtual Node* create_() = 0;
 
  std::string name_;
 
  size_t type_id_;
 
  std::vector< std::vector< Node* > > memory_;
};
 
 
inline Node*
Model::create( size_t t )
{
  assert( t < memory_.size() );
  Node* n = create_();
  memory_[ t ].emplace_back( n );
  return n;
}
 
inline std::string
Model::get_name() const
{
  return name_;
}
}
#endif