event.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_EVENT_H
#define SAMPA_EVENT_H

#include "sampa/core/object.h"
#include "sampa/core/triggerable.h"

namespace Sampa {

  class Time;
  class ActualEvent;
  class ActualEventSingle;
  class ActualAndEventSingle;
  class ActualAndEvent;
  class EventListenerSingle;
  class Clock;
  class ActualClock;
  
  class SAMPA_PERSISTENT_CLASS(EventFinder) {
  public:
    EventFinder(const EventFinder&);
    EventFinder(ActualEventSingle*);
    ~EventFinder();
    EventFinder& operator=(const EventFinder&);
    ActualEventSingle* resolve();
    ActualEventSingle* is_resolved() const;
    void unsubscribe(Triggerable*);  
    void subscribe(Triggerable*);
    void notify();
    void notify_in(const Time&);
    void notify_at(const Time&);
    class Helper;
    void set_actual_event(ActualEventSingle* event);
    ActualEventSingle* get_actual_event() const { return m_actual_event; }
  protected:
    void propagate_actual_event(ActualEventSingle* event);
    ActualEventSingle*  m_actual_event;
  private:
    Helper*             m_finder_group; // transient...
    SAMPA_PERSISTENT(EventFinder);  
  };

  class TemporaryEventExpression {
  public:
    TemporaryEventExpression(const TemporaryEventExpression& other) 
      { m_expression = other.m_expression; }
    TemporaryEventExpression& operator=(const TemporaryEventExpression& other) 
      { m_expression = other.m_expression; return *this; }
    ActualAndEventSingle* get_expression() const { return m_expression; }
    ActualAndEvent* convert_to_multiple_subscriber() const;
  private:
    bool is_or() const;
    bool is_and() const;
    TemporaryEventExpression(ActualAndEventSingle*);
    friend TemporaryEventExpression operator|(EventListenerSingle&, EventListenerSingle&);
    friend TemporaryEventExpression operator|(TemporaryEventExpression&, EventListenerSingle&);
    friend TemporaryEventExpression operator&(EventListenerSingle&, EventListenerSingle&);
    friend TemporaryEventExpression operator&(TemporaryEventExpression&, EventListenerSingle&);
    mutable ActualAndEventSingle* m_expression;
  };

  class EventListenerSingle : public Object {
  public:
    EventListenerSingle(const Name&); 
    EventListenerSingle& operator=(const EventListenerSingle&); 
    EventListenerSingle& operator=(const TemporaryEventExpression&); 

    EventListenerSingle(const EventListenerSingle&);
    ~EventListenerSingle();
    void unsubscribe(Triggerable&);  
    void subscribe(Triggerable&);  
    ActualEventSingle* is_resolved() const;
    ActualEventSingle* resolve();
    bool check_binding();  
    EventFinder& get_finder();
  protected:
    friend class ActualClock;
    void set_actual_event(ActualEventSingle*);
    EventListenerSingle(const Name&, ActualEventSingle*);
    EventListenerSingle(ActualEventSingle*);
    EventFinder                 m_finder;
    EventListenerSingle*        m_pool_next;
    static EventListenerSingle* M_pool;
    friend TemporaryEventExpression operator|(EventListenerSingle&, EventListenerSingle&);
    friend TemporaryEventExpression operator|(TemporaryEventExpression&, EventListenerSingle&);
    friend TemporaryEventExpression operator&(EventListenerSingle&, EventListenerSingle&);
    friend TemporaryEventExpression operator&(TemporaryEventExpression&, EventListenerSingle&); 
  public:
    SAMPA_PERSISTENT(EventListenerSingle);  
  };

  TemporaryEventExpression operator|(EventListenerSingle&, EventListenerSingle&);
  TemporaryEventExpression operator|(TemporaryEventExpression&, EventListenerSingle&);
  TemporaryEventExpression operator&(EventListenerSingle&, EventListenerSingle&);
  TemporaryEventExpression operator&(TemporaryEventExpression&, EventListenerSingle&);

  class EventSingle : public EventListenerSingle {
  public:
    EventSingle(const Name&);
    void notify();                     
    void notify_in(const Time& delay); 
    void notify_at(const Time& date);  

  private:
    // disabled
    EventSingle(const EventSingle&);
    EventSingle& operator=(const EventSingle&);
  public:
    SAMPA_PERSISTENT(EventSingle);  
  };

  class EventListener : public EventListenerSingle {
  public:
    EventListener(const Name&);
    EventListener& operator=(const TemporaryEventExpression&); 
    EventListener& operator=(const EventListener&); 

    EventListener(const EventListener&);
  protected:
    friend class Clock;
    EventListener(const Name&, ActualEventSingle*);
    EventListener(ActualEventSingle*);
      friend class ActualClock;
  public:
    SAMPA_PERSISTENT(EventListener);  
  };

  class Event : public EventListener {
  public:
    Event(const Name&);
    void notify();                     
    void notify_in(const Time& delay); 
    void notify_at(const Time& date);  

  private:
    // disabled
    Event(const Event&);
    Event& operator=(const Event&);
  public:
    SAMPA_PERSISTENT(Event);  
  };

  class ClockedEvent : public EventListener {
    SAMPA_PERSISTENT(ClockedEvent);
  public:
    ClockedEvent(const Name&);    
    void set_clock(Clock* clock)
      {  p_clock = clock; }
    Clock* get_clock() const 
      {  return p_clock; }
    void cancel(); 
    void notify(); 
    void notify_next_falling() 
      { notify_in_n_falling(1); }
    void notify_in_n_falling(int n); 
    void notify_next_rising() 
      { notify_in_n_rising(1); }
    void notify_in_n_rising(int n); 

    bool check_binding();
  private:
    ActualEvent* m_ev;
    Clock*       p_clock;
  };
  
  class ClockedEventSingle : public EventListenerSingle {
    SAMPA_PERSISTENT(ClockedEventSingle);
  public:
    ClockedEventSingle(const Name&);    
    void set_clock(Clock* clock)
      {  p_clock = clock; }
    Clock* get_clock() const 
      {  return p_clock; }
    void cancel(); 
    void notify(); 
    void notify_next_falling() 
      { notify_in_n_falling(1); }
    void notify_in_n_falling(int n); 
    void notify_next_rising() 
      { notify_in_n_rising(1); }
    void notify_in_n_rising(int n); 

    bool check_binding();
//    bool check_binding() { return p_clock != 0 }
  private:
    ActualEvent* m_ev;
    Clock*       p_clock;
  };

}

#endif

---