Linkage.hh

Go to the documentation of this file.

#ifndef COSA_LINKAGE_HH
#define COSA_LINKAGE_HH

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

class Linkage : public Event::Handler {
public:
  Linkage() :
    Event::Handler(),
    m_succ(this),
    m_pred(this)
  {}

  Linkage* succ() const
  {
    return (m_succ);
  }

  Linkage* pred() const
  {
    return (m_pred);
  }

  void attach(Linkage* pred)
  {
    synchronized {

      // Check if it needs to be detached first
      if (UNLIKELY(pred->m_succ != pred)) {
        pred->m_succ->m_pred = pred->m_pred;
        pred->m_pred->m_succ = pred->m_succ;
      }

      // Attach pred as the new predecessor
      pred->m_succ = this;
      pred->m_pred = this->m_pred;
      this->m_pred->m_succ = pred;
      this->m_pred = pred;
    }
  }

protected:
  Linkage* m_succ;
  Linkage* m_pred;

  void detach()
  {
    // Check that the detach is necessary
    if (UNLIKELY(m_succ == this)) return;

    // Unlink and initiate to self reference
    synchronized {
      m_succ->m_pred = m_pred;
      m_pred->m_succ = m_succ;
      m_succ = this;
      m_pred = this;
    }
  }
};

class Link : public Linkage {
public:
  Link() : Linkage() {}

  void detach()
    __attribute__((always_inline))
  {
    Linkage::detach();
  }
};

class Head : public Linkage {
public:
  Head() : Linkage() {}

  int available()
  {
    int res = 0;
    // Iterate through the list and count the length of the queue
    for (Linkage* link = m_succ; link != this; link = link->succ()) res++;
    return (res);
  }

  bool is_empty() const
  {
    return (m_succ == this);
  }

private:
  virtual void on_event(uint8_t type, uint16_t value)
  {
    // Iterate through the list and dispatch the event
    Linkage* link = m_succ;
    while (link != this) {
      // Get the successor as the current event call may detach itself
      Linkage* succ = link->succ();
      link->on_event(type, value);
      link = succ;
    }
  }
};

#endif