Event.hh

Go to the documentation of this file.

#ifndef COSA_EVENT_HH
#define COSA_EVENT_HH

#include "Cosa/Types.h"
#include "Cosa/Queue.hh"

// Default event queue size
#ifndef COSA_EVENT_QUEUE_MAX
# if defined(BOARD_ATTINY)
#   define COSA_EVENT_QUEUE_MAX 8
# else
#   define COSA_EVENT_QUEUE_MAX 16
# endif
#endif

class Event {
public:
  static const uint8_t QUEUE_MAX = COSA_EVENT_QUEUE_MAX;

  enum {
    NULL_TYPE = 0,

    FALLING_TYPE,               // Digital Pins
    RISING_TYPE,
    CHANGE_TYPE,

    SAMPLE_REQUEST_TYPE,        // Analog Pins
    SAMPLE_COMPLETED_TYPE,

    WATCHDOG_TYPE,              // Watchdog and timers
    TIMEOUT_TYPE,

    BEGIN_TYPE,                 // Finite State Machines
    END_TYPE,

    RUN_TYPE,                   // Thread

    CONNECT_TYPE,               // Device drivers and protocol stacks
    DISCONNECT_TYPE,
    RECEIVE_REQUEST_TYPE,
    RECEIVE_COMPLETED_TYPE,
    SEND_REQUEST_TYPE,
    SEND_COMPLETED_TYPE,

    OPEN_TYPE,                  // Device drivers and storage
    CLOSE_TYPE,
    READ_REQUEST_TYPE,
    READ_COMPLETED_TYPE,
    WRITE_REQUEST_TYPE,
    WRITE_COMPLETED_TYPE,
    COMMAND_REQUEST_TYPE,
    COMMAND_COMPLETED_TYPE,

    SERVICE_REQUEST_TYPE,       // Servers
    SERVICE_RESPONSE_TYPE,

    USER_TYPE = 64,             // User defined events/messages, 64-254

    ERROR_TYPE = 255            // Error event
  } __attribute__((packed));

  class Handler {
  public:
    virtual void on_event(uint8_t type, uint16_t value)
    {
      UNUSED(type);
      UNUSED(value);
    }
  };

public:
  Event(int8_t type = NULL_TYPE, Handler* target = NULL, uint16_t value = 0) :
    m_type(type),
    m_target(target),
    m_value(value)
  {}

  uint8_t type() const
  {
    return (m_type);
  }

  Handler* target() const
  {
    return (m_target);
  }

  uint16_t value() const
  {
    return (m_value);
  }

  void* env() const
  {
    return ((void*) m_value);
  }

  void dispatch()
    __attribute__((always_inline))
  {
    if (m_target != NULL) m_target->on_event(m_type, m_value);
  }

  static bool push(uint8_t type, Handler* target, uint16_t value = 0)
    __attribute__((always_inline))
  {
    Event event(type, target, value);
    return (queue.enqueue(&event));
  }

  static bool push(uint8_t type, Handler* target, void* env)
    __attribute__((always_inline))
  {
    return (push(type, target, (uint16_t) env));
  }

  static Queue<Event, QUEUE_MAX> queue;

  static bool service(uint32_t ms = 0L);

private:
  uint8_t m_type;               
  Handler* m_target;            
  uint16_t m_value;             
};

#endif