ost::Buffer - The buffer class represents an IPC service that is built upon a buffer of fixed capacity

       Generated automatically by Doxygen for GNU CommonC++ from the source code.

GNU CommonC++                                    Sun Dec 27 2020                                  ost::Buffer(3)

ost::Buffer::Buffer(size_tcapacity)
       Create a buffer object of known capacity.

       Parameterscapacity is the integer capacity of the buffer.

   virtualost::Buffer::~Buffer()[virtual]
       In derived functions, may be used to free the actual memory used to hold buffered data.

       The buffer class represents an IPC service that is built upon a buffer of fixed capacity that can be used
       to transfer objects between one or more producer and consumer threads.

       Producer threads post objects into the buffer, and consumer threads wait for and receive objects from the
       buffer. Semaphores are used to to block the buffer from overflowing and indicate when there is data
       available, and mutexes are used to protect multiple consumers and producer threads from stepping over
       each other.

       The buffer class is an abstract class in that the actual data being buffered is not directly specified
       within the buffer class itself. The buffer class should be used as a base class for a class that actually
       impliments buffering and which may be aware of the data types actually are being buffered. A template
       class could be created based on buffer for this purpose. Another possibility is to create a class derived
       from both Thread and Buffer which can be used to implement message passing threads.

       Author
           David Sugar dyfet@ostel.com

       Producer/Consumer buffer for use between threads.

size_tget(Buffer&b,void*o,timeout_tt=0)[related]
       References wait().

   size_tpeek(Buffer&b,void*o)[related]ExamplesSampleSocketPort.cpp.

       References peek().

   size_tput(Buffer&b,void*o,timeout_tt=0)[related]
       References post().

constsize_tost::Buffer::timeout[static]
       value to return when a timed operation returned with a timeout.

size_tost::Buffer::getSize(void)[inline]
       Return the capacity of the buffer as specified at creation.

       Returns
           size of buffer.

   size_tost::Buffer::getUsed(void)[inline]
       Return the current capacity in use for the buffer. Free space is technically getSize() - getUsed().

       Returns
           integer used capacity of the buffer.

       SeealsogetSizevirtualboolost::Buffer::isValid(void)[virtual]
       New virtual to test if buffer is a valid object.

       Returns
           true if object is valid.

       Reimplemented in ost::FixedBuffer.

   virtualsize_tost::Buffer::onPeek(void*buf)[protected],[purevirtual]
       Invoke derived class buffer peeking method.

       Returns
           size of object found.

       Parametersbuf pointer to copy contents of head of buffer to.

       Implemented in ost::FixedBuffer.

   virtualsize_tost::Buffer::onPost(void*buf)[protected],[purevirtual]
       Invoke derived class posting of object to buffer.

       Returns
           size of object posted.

       Parametersbuf pointer to object being posted to the buffer.

       Implemented in ost::FixedBuffer.

   virtualsize_tost::Buffer::onWait(void*buf)[protected],[purevirtual]
       Invoke derived class object request from buffer.

       Returns
           size of object returned.

       Parametersbuf pointer to hold object returned from the buffer.

       Implemented in ost::FixedBuffer.

   size_tost::Buffer::peek(void*buf)
       Peek at the current content (first object) in the buffer.

       Returns
           size of object in the buffer.

       Parametersbuf pointer to store object found in the buffer.

       Referenced by peek().

   size_tost::Buffer::post(void*buf,timeout_ttimeout=0)
       Post an object into the buffer and enable a waiting thread to receive it.

       Returns
           size of object posted in bytes.

       Parametersbuf pointer to object to store in the buffer.
           timeout time to wait.

       Referenced by put().

   size_tost::Buffer::wait(void*buf,timeout_ttimeout=0)
       Let one or more threads wait for an object to become available in the buffer. The waiting thread(s) will
       wait forever if no object is ever placed into the buffer.

       Returns
           size of object passed by buffer in bytes.

       Parametersbuf pointer to store object retrieved from the buffer.
           timeout time to wait.

       Referenced by get().

       ost::Buffer - The buffer class represents an IPC service that is built upon a buffer of fixed capacity
       that can be used to transfer objects between one or more producer and consumer threads.

       #include <buffer.h>

       Inherits ost::Conditional.

       Inherited by ost::FixedBuffer.

   PublicMemberFunctionsBuffer (size_t capacity)
           Create a buffer object of known capacity.
       virtual ~Buffer ()
           In derived functions, may be used to free the actual memory used to hold buffered data.
       size_t getSize (void)
           Return the capacity of the buffer as specified at creation.
       size_t getUsed (void)
           Return the current capacity in use for the buffer.
       size_t wait (void *buf, timeout_ttimeout=0)
           Let one or more threads wait for an object to become available in the buffer.
       size_t post (void *buf, timeout_ttimeout=0)
           Post an object into the buffer and enable a waiting thread to receive it.
       size_t peek (void *buf)
           Peek at the current content (first object) in the buffer.
       virtual bool isValid (void)
           New virtual to test if buffer is a valid object.

   StaticPublicAttributes
       static const size_t timeout
           value to return when a timed operation returned with a timeout.

   ProtectedMemberFunctions
       virtual size_t onPeek (void *buf)=0
           Invoke derived class buffer peeking method.
       virtual size_t onWait (void *buf)=0
           Invoke derived class object request from buffer.
       virtual size_t onPost (void *buf)=0
           Invoke derived class posting of object to buffer.

   RelatedFunctions
       (Note that these are not member functions.)
       size_t get (Buffer &b, void *o, timeout_t t=0)
       size_t put (Buffer &b, void *o, timeout_t t=0)
       size_t peek (Buffer &b, void *o)