gated.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_GATED_H
#define SAMPA_GATED_H

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

namespace Sampa {

  class Simulation;

  class GatedBase : public ContainerObject, public Triggerable { 
  // would have used protected Triggerable, but serialize doesn't work then...
  public:
    typedef ContainerObject::Name Name;
    GatedBase(const Name& nm);   
    void set_gate_event(EventListener& event); 

    bool check_binding();
  protected:
    int m_curr;
    void request_update();
  private:
    void trigger();
    // disabled
    GatedBase(const GatedBase&);
    GatedBase& operator=(const GatedBase&);
    // state
    EventListener* m_sync;
    bool           m_notified;
  public:
    SAMPA_PERSISTENT(GatedBase);
  };

  class Module;

  template<class UserType>
  class Gated : public GatedBase {
  public:
    typedef GatedBase::Name Name;
    Gated(const Name& name, const UserType& default_value);
    void schedule(const UserType& v);      
    void force(const UserType& v);         
    const UserType& read() const;          
    const UserType& get_next() const;      
    operator const UserType&() const;      
    UserType* operator->() { return &m_value[m_curr]; }
  private:
    // disabled
    Gated(const Gated&);
    Gated& operator=(const UserType& v);
    // state  
    UserType m_value[2];
  public:
    SAMPA_PERSISTENT(Gated);
  };

  inline void GatedBase::set_gate_event(EventListener& event)
  { 
    m_sync = &event; 
  }

  template<class UserType>
  inline Gated<UserType>::operator const UserType&() const                  
  { 
    return m_value[m_curr]; 
  }

  template<class UserType>
  inline const UserType& Gated<UserType>::read() const                  
  { 
    return m_value[m_curr]; 
  }

  template<class UserType>
  inline const UserType& Gated<UserType>::get_next() const                  
  { 
    return m_value[1-m_curr]; 
  }

} // namespace Sampa

#endif

---