diff options
Diffstat (limited to 'ACE/ace/Message_Queue_Vx.h')
-rw-r--r-- | ACE/ace/Message_Queue_Vx.h | 226 |
1 files changed, 226 insertions, 0 deletions
diff --git a/ACE/ace/Message_Queue_Vx.h b/ACE/ace/Message_Queue_Vx.h new file mode 100644 index 00000000000..42f376693e1 --- /dev/null +++ b/ACE/ace/Message_Queue_Vx.h @@ -0,0 +1,226 @@ +// -*- C++ -*- + +//============================================================================= +/** + * @file Message_Queue_Vx.h + * + * $Id$ + * + * @author Douglas C. Schmidt <schmidt@cs.wustl.edu> + */ +//============================================================================= + +#ifndef ACE_MESSAGE_QUEUE_VX_H +#define ACE_MESSAGE_QUEUE_VX_H +#include /**/ "ace/pre.h" + +#include "ace/Message_Block.h" + +#if !defined (ACE_LACKS_PRAGMA_ONCE) +# pragma once +#endif /* ACE_LACKS_PRAGMA_ONCE */ + +#if defined (ACE_VXWORKS) + +// Include the templates here. +#include "ace/Message_Queue_T.h" + +# include /**/ <msgQLib.h> +# include "ace/Null_Mutex.h" +# include "ace/Null_Condition.h" + +ACE_BEGIN_VERSIONED_NAMESPACE_DECL + +/** + * @class ACE_Message_Queue_Vx + * + * @brief Wrapper for VxWorks message queues. + * + * Specialization of ACE_Message_Queue to simply wrap VxWorks + * MsgQ. It does not use any synchronization, because it relies + * on the native MsgQ implementation to take care of that. The + * only system calls that it uses are VxWorks msgQLib calls, so + * it is suitable for use in interrupt service routines. + * @note *Many* ACE_Message_Queue features are not supported with + * this specialization, including: + * * The two size arguments to the constructor and <open> are + * interpreted differently. The first is interpreted as the + * maximum number of bytes in a message. The second is + * interpreted as the maximum number of messages that can be + * queued. + * * <dequeue_head> *requires* that the ACE_Message_Block + * pointer argument point to an ACE_Message_Block that was + * allocated by the caller. It must be big enough to support + * the received message, without using continuation. The + * pointer argument is not modified. + * * Message priority. MSG_Q_FIFO is hard-coded. + * * enqueue method timeouts. + * * <peek_dequeue_head>. + * * <ACE_Message_Queue_Iterators>. + * * The ability to change low and high water marks after creation. + * * Message_Block chains. The continuation field of ACE_Message_Block + * * is ignored; only the first block of a fragment chain is + * * recognized. + */ +class ACE_Export ACE_Message_Queue_Vx: public ACE_Message_Queue<ACE_NULL_SYNCH> +{ +public: + // = Initialization and termination methods. + ACE_Message_Queue_Vx (size_t max_messages, + size_t max_message_length, + ACE_Notification_Strategy * = 0); + + // Create a message queue with all the defaults. + /// Create a message queue with all the defaults. + virtual int open (size_t max_messages, + size_t max_message_length, + ACE_Notification_Strategy * = 0); + + /// Close down the message queue and release all resources. + virtual int close (void); + + /// Close down the message queue and release all resources. + virtual ~ACE_Message_Queue_Vx (void); + + // = Queue statistic methods. + /** + * Number of total bytes on the queue, i.e., sum of the message + * block sizes. + */ + virtual size_t message_bytes (void); + + /** + * Number of total length on the queue, i.e., sum of the message + * block lengths. + */ + virtual size_t message_length (void); + + /** + * Number of total messages on the queue. + */ + virtual size_t message_count (void); + + // = Manual changes to these stats (used when queued message blocks + // change size or lengths). + /** + * New value of the number of total bytes on the queue, i.e., sum of + * the message block sizes. + */ + virtual void message_bytes (size_t new_size); + + /** + * New value of the number of total length on the queue, i.e., sum + * of the message block lengths. + */ + virtual void message_length (size_t new_length); + + // = Flow control routines + + /// Get high watermark. + virtual size_t high_water_mark (void); + + /// Set high watermark. + virtual void high_water_mark (size_t hwm); + + /// Get low watermark. + virtual size_t low_water_mark (void); + + /// Set low watermark. + virtual void low_water_mark (size_t lwm); + + // = Activation control methods. + + /// Dump the state of an object. + void dump (void) const; + + /// Declare the dynamic allocation hooks. + ACE_ALLOC_HOOK_DECLARE; + +protected: + /// Enqueue an ACE_Message_Block * in accordance with its priority. + virtual int enqueue_i (ACE_Message_Block *new_item); + + /// Enqueue an ACE_Message_Block * in accordance with its deadline time. + virtual int enqueue_deadline_i (ACE_Message_Block *new_item); + + /// Enqueue an <ACE_Message_Block *> at the end of the queue. + virtual int enqueue_tail_i (ACE_Message_Block *new_item); + + /// Enqueue an <ACE_Message_Block *> at the head of the queue. + virtual int enqueue_head_i (ACE_Message_Block *new_item); + + /// Dequeue and return the <ACE_Message_Block *> at the head of the + /// queue. + virtual int dequeue_head_i (ACE_Message_Block *&first_item); + + /// Dequeue and return the <ACE_Message_Block *> with the lowest + /// priority. + virtual int dequeue_prio_i (ACE_Message_Block *&dequeued); + + /// Dequeue and return the <ACE_Message_Block *> at the tail of the + /// queue. + virtual int dequeue_tail_i (ACE_Message_Block *&dequeued); + + /// Dequeue and return the <ACE_Message_Block *> that has the lowest + /// deadline time. + virtual int dequeue_deadline_i (ACE_Message_Block *&dequeued); + + // = Check the boundary conditions (assumes locks are held). + /// True if queue is full, else false. + virtual bool is_full_i (void); + + /// True if queue is empty, else false. + virtual bool is_empty_i (void); + + // = Implementation of public <activate>/<deactivate> methods above. + + // These methods assume locks are held. + + // = Helper methods to factor out common #ifdef code. + /// Wait for the queue to become non-full. + virtual int wait_not_full_cond (ACE_Time_Value *tv); + + /// Wait for the queue to become non-empty. + virtual int wait_not_empty_cond (ACE_Time_Value *tv); + + /// Inform any threads waiting to enqueue that they can procede. + virtual int signal_enqueue_waiters (void); + + /// Inform any threads waiting to dequeue that they can procede. + virtual int signal_dequeue_waiters (void); + + /// Access the underlying msgQ. + MSG_Q_ID msgq (void); + +private: + + // Disallow copying and assignment. + ACE_Message_Queue_Vx (const ACE_Message_Queue_Vx &); + void operator= (const ACE_Message_Queue_Vx &); + + ACE_UNIMPLEMENTED_FUNC (virtual int peek_dequeue_head + (ACE_Message_Block *&first_item, + ACE_Time_Value *tv = 0)) + +private: + /// Maximum number of messages that can be queued. + int max_messages_; + + /// Maximum message size, in bytes. + int max_message_length_; + + /// Native message queue options. + int options_; + +}; + +ACE_END_VERSIONED_NAMESPACE_DECL + +#endif /* ACE_VXWORKS */ + +#if defined (__ACE_INLINE__) +#include "ace/Message_Queue_Vx.inl" +#endif /* __ACE_INLINE__ */ + +#include /**/ "ace/post.h" +#endif /* ACE_MESSAGE_QUEUE_VX_H */ |