AthenaInterprocess::SharedQueue Class Reference

#include <SharedQueue.h>

Inheritance diagram for AthenaInterprocess::SharedQueue:

Collaboration diagram for AthenaInterprocess::SharedQueue:

Public Member Functions
	SharedQueue ()
	SharedQueue (const std::string &name, int max_msg=SHAREDQUEUE_MAX_MSG, std::size_t max_size=MAX_MSG_SIZE, bool do_unlink=true)
	SharedQueue (const SharedQueue &other)
SharedQueue &	operator= (const SharedQueue &other)
virtual	~SharedQueue ()
std::string	name () const
virtual bool	try_send (const std::string &)
virtual bool	send (const std::string &)
virtual std::string	try_receive ()
virtual std::string	receive ()
template<typename T>
bool	try_send_basic (T)
template<typename T>
bool	send_basic (T)
template<typename T>
bool	try_receive_basic (T &)
template<typename T>
bool	receive_basic (T &)
	operator bool () const

Protected Member Functions
boost::interprocess::message_queue *	operator-> ()

Private Member Functions
void	copy (const SharedQueue &other)
void	destroy ()
template<typename T>
bool	do_send_basic (T, bool)
template<typename T>
bool	do_receive_basic (T &, bool)

Private Attributes
boost::interprocess::message_queue *	m_queue
std::string *	m_name
int *	m_count

Detailed Description

Definition at line 21 of file SharedQueue.h.

Constructor & Destructor Documentation

SharedQueue() [1/3]

AthenaInterprocess::SharedQueue::SharedQueue

(

)

Definition at line 16 of file SharedQueue.cxx.

                         : m_queue( 0 ), m_name( 0 ), m_count( 0 )
{
/* empty */
}

SharedQueue() [2/3]

AthenaInterprocess::SharedQueue::SharedQueue	(	const std::string &	name,
		int	max_msg = SHAREDQUEUE_MAX_MSG,
		std::size_t	max_size = MAX_MSG_SIZE,
		bool	do_unlink = true )

Definition at line 21 of file SharedQueue.cxx.

                                                                                                   :
      m_queue( 0 ), m_name( 0 ), m_count( 0 )
{
   m_queue = new message_queue( open_or_create, name.c_str(), max_msg, max_size );
   if ( do_unlink )
      message_queue::remove( name.c_str() );
 
   m_count = new int( 1 );
   m_name = new std::string( name );
}

SharedQueue() [3/3]

AthenaInterprocess::SharedQueue::SharedQueue

(

const SharedQueue &

other

)

Definition at line 32 of file SharedQueue.cxx.

{
   copy( other );
}

~SharedQueue()

AthenaInterprocess::SharedQueue::~SharedQueue ( )

virtual

Definition at line 47 of file SharedQueue.cxx.

{
   destroy();
}

Member Function Documentation

copy()

void AthenaInterprocess::SharedQueue::copy ( const SharedQueue & other )

private

Definition at line 53 of file SharedQueue.cxx.

{
   if ( other.m_count ) {
      *other.m_count += 1;
      m_count = other.m_count;
      m_queue = other.m_queue;
      m_name = other.m_name;
   } else {
      m_count = 0;
      m_queue = 0;
      m_name = 0;
   }
}

destroy()

void AthenaInterprocess::SharedQueue::destroy ( )

private

Definition at line 67 of file SharedQueue.cxx.

{
   if ( m_count && --*m_count <= 0 ) {
      delete m_queue; m_queue = 0;
   //      message_queue::remove( m_name->c_str() );
      delete m_name; m_name = 0;
      delete m_count; m_count = 0;
   }
}

do_receive_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::do_receive_basic ( T & data, bool block )

private

Definition at line 98 of file SharedQueue.h.

{
  unsigned int priority = 0;
  std::size_t recvd_size = 0;
  bool receive_ok = true;
 
  try {
    if(block) {
      m_queue->receive(&data,sizeof(T),recvd_size,priority);
    }
    else {
      receive_ok = m_queue->try_receive(&data,sizeof(T),recvd_size,priority);
    }
  }
  catch(boost::interprocess::interprocess_exception&) {
    return false; // TODO: perhaps add a printout or something
  }
 
  return receive_ok;
}

do_send_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::do_send_basic ( T data, bool block )

private

Definition at line 71 of file SharedQueue.h.

{
  bool send_ok = true;
 
  try {
    if(block)
      m_queue->send(&data, sizeof(data), 0);
    else
      send_ok = m_queue->try_send(&data, sizeof(data), 0);
  } 
  catch(boost::interprocess::interprocess_exception&) {
    send_ok = false;
  }
 
  return send_ok;
}

name()

std::string AthenaInterprocess::SharedQueue::name

(

)

const

Definition at line 78 of file SharedQueue.cxx.

{
   if ( m_name )
      return *m_name;
   return "";
}

operator bool()

AthenaInterprocess::SharedQueue::operator bool ( ) const

inline

Definition at line 49 of file SharedQueue.h.

                         {
      return (bool)m_queue;
   }

operator->()

boost::interprocess::message_queue * AthenaInterprocess::SharedQueue::operator-> ( )

inlineprotected

Definition at line 54 of file SharedQueue.h.

                                                {
      return m_queue;
   }

operator=()

SharedQueue & AthenaInterprocess::SharedQueue::operator=

(

const SharedQueue &

other

)

Definition at line 37 of file SharedQueue.cxx.

{
   if ( &other != this ) {
      destroy();
      copy( other );
   }
 
   return *this;
}

receive()

std::string AthenaInterprocess::SharedQueue::receive ( )

virtual

Reimplemented in AthenaInterprocess::IdentifiedSharedQueue.

Definition at line 145 of file SharedQueue.cxx.

{
   return do_receive( m_queue, true );
}

receive_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::receive_basic

(

T &

data

)

Definition at line 124 of file SharedQueue.h.

{
  return do_receive_basic(data,true);
}

send()

bool AthenaInterprocess::SharedQueue::send ( const std::string & buf )

virtual

Reimplemented in AthenaInterprocess::IdentifiedSharedQueue.

Definition at line 107 of file SharedQueue.cxx.

{
   return do_send( m_queue, buf, true );
}

send_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::send_basic

(

T

data

)

Definition at line 93 of file SharedQueue.h.

{
  return do_send_basic<T>(data,true);
}

try_receive()

std::string AthenaInterprocess::SharedQueue::try_receive ( )

virtual

Reimplemented in AthenaInterprocess::IdentifiedSharedQueue.

Definition at line 140 of file SharedQueue.cxx.

{
  return do_receive( m_queue, false );
}

try_receive_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::try_receive_basic

(

T &

data

)

Definition at line 119 of file SharedQueue.h.

{
  return do_receive_basic(data,false);
}

try_send()

bool AthenaInterprocess::SharedQueue::try_send ( const std::string & buf )

virtual

Reimplemented in AthenaInterprocess::IdentifiedSharedQueue.

Definition at line 102 of file SharedQueue.cxx.

{
   return do_send( m_queue, buf, false );
}

try_send_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::try_send_basic

(

T

data

)

Definition at line 88 of file SharedQueue.h.

{
  return do_send_basic<T>(data,false);
}

Member Data Documentation

m_count

int* AthenaInterprocess::SharedQueue::m_count

private

Definition at line 68 of file SharedQueue.h.

m_name

std::string* AthenaInterprocess::SharedQueue::m_name

private

Definition at line 67 of file SharedQueue.h.

m_queue

boost::interprocess::message_queue* AthenaInterprocess::SharedQueue::m_queue

private

Definition at line 66 of file SharedQueue.h.

---

The documentation for this class was generated from the following files:

• SharedQueue.h
• SharedQueue.cxx