AthenaInterprocess::IdentifiedSharedQueue Class Reference

#include <IdentifiedSharedQueue.h>

Inheritance diagram for AthenaInterprocess::IdentifiedSharedQueue:

Collaboration diagram for AthenaInterprocess::IdentifiedSharedQueue:

Public Member Functions
	IdentifiedSharedQueue ()
	IdentifiedSharedQueue (const std::string &name, int max_msg=SHAREDQUEUE_MAX_MSG, std::size_t max_size=MAX_MSG_SIZE, bool do_unlink=true)
virtual bool	try_send (const std::string &)
virtual bool	send (const std::string &)
virtual std::string	try_receive ()
virtual std::string	try_receive (pid_t &id)
virtual std::string	receive ()
virtual std::string	receive (pid_t &id)
std::string	name () const
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 14 of file IdentifiedSharedQueue.h.

Constructor & Destructor Documentation

IdentifiedSharedQueue() [1/2]

AthenaInterprocess::IdentifiedSharedQueue::IdentifiedSharedQueue

(

)

Definition at line 19 of file IdentifiedSharedQueue.cxx.

                                             : SharedQueue()
{
/* empty */
}

IdentifiedSharedQueue() [2/2]

AthenaInterprocess::IdentifiedSharedQueue::IdentifiedSharedQueue	(	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 24 of file IdentifiedSharedQueue.cxx.

                                                                                                                       :
    SharedQueue( name, max_msg, max_size, do_unlink )
{
/* empty */
}

Member Function Documentation

copy()

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

privateinherited

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 ( )

privateinherited

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 )

privateinherited

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 )

privateinherited

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

inherited

Definition at line 78 of file SharedQueue.cxx.

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

operator bool()

AthenaInterprocess::SharedQueue::operator bool ( ) const

inlineinherited

Definition at line 49 of file SharedQueue.h.

                         {
      return (bool)m_queue;
   }

operator->()

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

inlineprotectedinherited

Definition at line 54 of file SharedQueue.h.

                                                {
      return m_queue;
   }

receive() [1/2]

std::string AthenaInterprocess::IdentifiedSharedQueue::receive ( )

virtual

Reimplemented from AthenaInterprocess::SharedQueue.

Definition at line 73 of file IdentifiedSharedQueue.cxx.

{
   pid_t pid;
   return receive( pid );
}

receive() [2/2]

std::string AthenaInterprocess::IdentifiedSharedQueue::receive ( pid_t & id )

virtual

Definition at line 79 of file IdentifiedSharedQueue.cxx.

{
   const std::string& buf = this->SharedQueue::receive();
   return get_pid( buf, id );
}

receive_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::receive_basic ( T & data )

inherited

Definition at line 124 of file SharedQueue.h.

{
  return do_receive_basic(data,true);
}

send()

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

virtual

Reimplemented from AthenaInterprocess::SharedQueue.

Definition at line 43 of file IdentifiedSharedQueue.cxx.

{
   return this->SharedQueue::send( add_pid( buf ) );
}

send_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::send_basic ( T data )

inherited

Definition at line 93 of file SharedQueue.h.

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

try_receive() [1/2]

std::string AthenaInterprocess::IdentifiedSharedQueue::try_receive ( )

virtual

Reimplemented from AthenaInterprocess::SharedQueue.

Definition at line 61 of file IdentifiedSharedQueue.cxx.

{
   pid_t pid;
   return try_receive( pid );
}

try_receive() [2/2]

std::string AthenaInterprocess::IdentifiedSharedQueue::try_receive ( pid_t & id )

virtual

Definition at line 67 of file IdentifiedSharedQueue.cxx.

{
   const std::string& buf = this->SharedQueue::try_receive();
   return get_pid( buf, id );
}

try_receive_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::try_receive_basic ( T & data )

inherited

Definition at line 119 of file SharedQueue.h.

{
  return do_receive_basic(data,false);
}

try_send()

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

virtual

Reimplemented from AthenaInterprocess::SharedQueue.

Definition at line 38 of file IdentifiedSharedQueue.cxx.

{
   return this->SharedQueue::try_send( add_pid( buf ) );
}

try_send_basic()

template<typename T>

bool AthenaInterprocess::SharedQueue::try_send_basic ( T data )

inherited

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

privateinherited

Definition at line 68 of file SharedQueue.h.

m_name

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

privateinherited

Definition at line 67 of file SharedQueue.h.

m_queue

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

privateinherited

Definition at line 66 of file SharedQueue.h.

---

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

• IdentifiedSharedQueue.h
• IdentifiedSharedQueue.cxx