sender.h

Go to the documentation of this file.

// AUTOMATICALLY GENERATED -- DO NOT EDIT!         -*- c++ -*-

#ifndef sender_h
#define sender_h

#include "l4_types.h"

//
// INTERFACE definition follows 
//


class Receiver;

class Sender
{
public:
  virtual void ipc_receiver_ready() = 0;

protected:
  Receiver *  _receiver;

private:
  Global_id   _id;
  Sender *sender_next, *sender_prev;

  friend class Jdb;
  friend class Jdb_thread_list;

public:  
  inline Global_id id() const;
  
  inline Receiver * receiver() const;
  
  // 
  // queueing functions
  // 
  
  inline bool in_sender_list();
  
  inline void sender_dequeue(Sender **r);

protected:  
  //
  // state requests/manipulation
  //
  
  explicit inline Sender(const Global_id& id, int /*ignored*/);
  
  inline void set_receiver(Receiver* receiver);
  
  inline void sender_enqueue(Sender **r);
  
  inline Sender(const Global_id& id);
};

//
// IMPLEMENTATION includes follow (for use by inline functions)
//


#include <cassert>

#include "cpu_lock.h"
#include "lock_guard.h"

//
// IMPLEMENTATION of inline functions (and needed classes)
//



inline Global_id
Sender::id() const
{
  return _id;
}


inline Receiver *
Sender::receiver() const
{
  return _receiver;
}


// 
// queueing functions
// 

inline bool 
Sender::in_sender_list()
{
  return sender_next;
}


inline void
Sender::sender_dequeue(Sender **r)
{
  Lock_guard<Cpu_lock> guard (&cpu_lock);

  if (in_sender_list())
    {
      if (sender_next == this)  // are we alone in the list?
        {
          assert(*r == this);

          *r = 0;
        }
      else
        {
          if (*r == this) // are we first in the list?
            *r = sender_next;

          sender_prev->sender_next = sender_next;
          sender_next->sender_prev = sender_prev;
        }

      sender_next = 0;
    }
}


//
// state requests/manipulation
//

inline Sender::Sender(const Global_id& id, int /*ignored*/)
      : _receiver (0),
        _id (id)
{}


inline void
Sender::set_receiver(Receiver* receiver)
{
  _receiver = receiver;
}


inline void
Sender::sender_enqueue(Sender **r)
{
  Lock_guard<Cpu_lock> guard (&cpu_lock);

  if (! in_sender_list())
    {
      if (*r)
        {
          sender_next = *r;
          sender_prev = sender_next->sender_prev;
          sender_prev->sender_next = this;
          sender_next->sender_prev = this;
        }
      else
        {
          *r = sender_prev = sender_next = this;
        }
    }
}


inline Sender::Sender(const Global_id& id)
  : _id (id), sender_next (0)
{}

#endif // sender_h

---