/* -*- C++ -*- */ //============================================================================= /** * @file Stream.h * * $Id$ * * @author Doug Schmidt */ //============================================================================= #ifndef ACE_STREAM_H #define ACE_STREAM_H #include "ace/pre.h" #include "ace/ACE.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ #include "ace/IO_Cntl_Msg.h" #include "ace/Message_Block.h" #include "ace/Time_Value.h" #include "ace/Module.h" // Forward decls. template class ACE_Stream_Iterator; /** * @class ACE_Stream * * @brief This class is the primary abstraction for the ASX framework. * It is moduled after System V Stream. * * A Stream consists of a stack of , each of which * contains two . Even though the methods in this * class are virtual, this class isn't really intended for * subclassing unless you know what you are doing. In * particular, the destructor calls , which * won't be overridden properly unless you call it in a subclass * destructor. */ template class ACE_Stream { public: friend class ACE_Stream_Iterator; enum { /// Indicates that deletes the Tasks. Don't change this /// value without updating the same enum in class ACE_Module... M_DELETE = 3 }; // = Initializatation and termination methods. /** * Create a Stream consisting of and as the Stream * head and Stream tail, respectively. If these are 0 then the * and are used, respectively. * is the value past in to the methods of the tasks. */ ACE_Stream (void *arg = 0, ACE_Module *head = 0, ACE_Module *tail = 0); /** * Create a Stream consisting of and as the Stream * head and Stream tail, respectively. If these are 0 then the * and are used, respectively. * is the value past in to the methods of the tasks. */ virtual int open (void *arg, ACE_Module *head = 0, ACE_Module *tail = 0); /// Close down the stream and release all the resources. virtual int close (int flags = M_DELETE); /// Close down the stream and release all the resources. virtual ~ACE_Stream (void); // = ACE_Stream plumbing operations /// Add a new module right below the Stream head. virtual int push (ACE_Module *mod); /// Remove the right below the Stream head and close it down. virtual int pop (int flags = M_DELETE); /// Return the top module on the stream (right below the stream /// head). virtual int top (ACE_Module *&mod); /// Insert a new module below the named module . virtual int insert (const ACE_TCHAR *prev_name, ACE_Module *mod); /// Replace the named module with a new module . virtual int replace (const ACE_TCHAR *replace_name, ACE_Module *mod, int flags = M_DELETE); /// Remove the named module from the stream. This bypasses the /// strict LIFO ordering of and . virtual int remove (const ACE_TCHAR *mod, int flags = M_DELETE); /// Return current stream head. virtual ACE_Module *head (void); /// Return current stream tail. virtual ACE_Module *tail (void); /// Find a particular ACE_Module. virtual ACE_Module *find (const ACE_TCHAR *mod); /// Create a pipe between two Streams. virtual int link (ACE_Stream &); /// Remove a pipe formed between two Streams. virtual int unlink (void); // = Blocking data transfer operations /** * Send the message down the stream, starting at the Module * below the Stream head. Wait for upto amount of * absolute time for the operation to complete (or block forever if * == 0). */ virtual int put (ACE_Message_Block *mb, ACE_Time_Value *timeout = 0); /** * Read the message that is stored in the the stream head. * Wait for upto amount of absolute time for the operation * to complete (or block forever if == 0). */ virtual int get (ACE_Message_Block *&mb, ACE_Time_Value *timeout = 0); /// Send control message down the stream. virtual int control (ACE_IO_Cntl_Msg::ACE_IO_Cntl_Cmds cmd, void *args); /// Synchronize with the final close of the stream. virtual int wait (void); /// Dump the state of an object. virtual void dump (void) const; /// Declare the dynamic allocation hooks. ACE_ALLOC_HOOK_DECLARE; private: /// Actually perform the unlinking of two Streams (must be called /// with locks held). int unlink_i (void); /// Actually perform the linking of two Streams (must be called with /// locks held). int link_i (ACE_Stream &); /// Must a new module onto the Stream. int push_module (ACE_Module *, ACE_Module * = 0, ACE_Module * = 0); /// Pointer to the head of the stream. ACE_Module *stream_head_; /// Pointer to the tail of the stream. ACE_Module *stream_tail_; /// Pointer to an adjoining linked stream. ACE_Stream *linked_us_; // = Synchronization objects used for thread-safe streams. /// Protect the stream against race conditions. ACE_SYNCH_MUTEX_T lock_; /// Use to tell all threads waiting on the close that we are done. ACE_SYNCH_CONDITION_T final_close_; }; /** * @class ACE_Stream_Iterator * * @brief Iterate through an . */ template class ACE_Stream_Iterator { public: // = Initialization method. ACE_Stream_Iterator (const ACE_Stream &sr); // = Iteration methods. /// Pass back the that hasn't been seen in the set. /// Returns 0 when all items have been seen, else 1. int next (const ACE_Module *&next_item); /// Returns 1 when all items have been seen, else 0. int done (void) const; /// Move forward by one element in the set. Returns 0 when all the /// items in the set have been seen, else 1. int advance (void); private: /// Next that we haven't yet seen. ACE_Module *next_; }; #if defined (__ACE_INLINE__) #include "ace/Stream.i" #endif /* __ACE_INLINE__ */ #if defined (ACE_TEMPLATES_REQUIRE_SOURCE) #include "ace/Stream.cpp" #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) #pragma implementation ("Stream.cpp") #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ #include "ace/post.h" #endif /* ACE_STREAM_H */