module.h

Go to the documentation of this file.

//    sampalib.org ESL library and tools
//    Copyright (C) 2007  Thierry Grellier
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License version 2 as
//    published by the Free Software Foundation.
//
//    This program 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 this program; if not, write to the Free Software Foundation, Inc.,
//    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//    contact: www.sampalib.org

#ifndef SAMPA_MODULE_H
#define SAMPA_MODULE_H

#include <string>
#include "sampa/core/triggerable.h"
#include "sampa/core/object.h"

namespace Sampa {

class EventListenerSingle;
class Simulation;
    
class ProcessBase : public Object, public Triggerable {
// would have used protected Triggerable, but serialize doesn't work then...
public:
  ProcessBase(const Name& nm);   
  ProcessBase& set_next_trigger(EventListenerSingle& event);
  ProcessBase& dont_initialize();
protected:
  virtual EventListenerSingle* execute() = 0;  
  EventListenerSingle* m_trigger;
private:
  friend class Simulation;
  void trigger();
  // disabled
  ProcessBase(const ProcessBase&);
  ProcessBase& operator=(const ProcessBase&);
  // state
  bool           m_dont_initialize;
  SAMPA_PERSISTENT(ProcessBase);
};

class Module;

template<class UserModule>
class Process : public ProcessBase {
public:
  typedef void (UserModule::*Method)();
  Process(const Name& name, UserModule* module, Method method);
  void restart(Method method) { m_method = method; }
private:
  EventListenerSingle* execute();
  // disabled
  Process(const Process&);
  Process& operator=(const Process&);
  // state  
  UserModule* m_module;
  Method      m_method; // need to be restored at restart
public:
  SAMPA_PERSISTENT(Process); 
};

class Module : public ContainerObject {
public:  
  Module(const ContainerName& nm);
protected:
  void set_next_trigger(EventListenerSingle&);
private:
  // disabled
  Module(const Module&);
  Module& operator=(const Module&);
  typedef Sampa::Process<Module> Process;
  Process& create_process(const std::string& name, Process::Method method);
  void restart_process(const std::string& name, Process::Method method);
protected:
  ProcessBase* __get_process_by_name(const std::string& name);
public:
  SAMPA_PERSISTENT(Module);
};

# define SAMPA_MODULE(Class)                                                 \
  SAMPA_PERSISTENT(Class);                                                    \
  public:                                                                     \
    typedef Sampa::Process<Class> Process;                                    \
  private:                                                                    \
    Process& create_process(const std::string& name, Process::Method method); \
    void restart_process(const std::string& name, Process::Method method);    \
    Class(const Class&);                                                      \
    Class& operator=(const Class&);

# define SAMPA_TEMPLATE_MODULE(Class)                                         \
  SAMPA_PERSISTENT(Class);                                                    \
  public:                                                                     \
    typedef Sampa::Process<Class> Process;                                    \
  private:                                                                    \
    Process& create_process(const std::string& name, typename Process::Method method); \
    void restart_process(const std::string& name, typename Process::Method method);    \
    Class(const Class&);                                                      \
    Class& operator=(const Class&);

inline ProcessBase& ProcessBase::set_next_trigger(EventListenerSingle& event)
{ 
  m_trigger = &event; 
  return *this;
}

} // namespace Sampa


#endif

---