Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | File List | Namespace Members | Class Members | File Members | Related Pages | Search for 

ACE_FIFO_Recv_Msg Class Reference

Receiver side for the record oriented C++ wrapper for UNIX FIFOs. More...

#include <FIFO_Recv_Msg.h>

Inheritance diagram for ACE_FIFO_Recv_Msg:

Inheritance graph
[legend]
Collaboration diagram for ACE_FIFO_Recv_Msg:

Collaboration graph
[legend]
List of all members.

Public Member Functions

 ACE_FIFO_Recv_Msg (void)
 Default constructor.

 ACE_FIFO_Recv_Msg (const ACE_TCHAR *rendezvous, int flags=O_CREAT|O_RDONLY, mode_t perms=ACE_DEFAULT_FILE_PERMS, int persistent=1, LPSECURITY_ATTRIBUTES sa=0)
 Open up a record-oriented named pipe for reading.

int open (const ACE_TCHAR *rendezvous, int flags=O_CREAT|O_RDONLY, mode_t perms=ACE_DEFAULT_FILE_PERMS, int persistent=1, LPSECURITY_ATTRIBUTES sa=0)
 Open up a record-oriented named pipe for reading.

ssize_t recv (ACE_Str_Buf &msg)
 Receive a message based on attributes in an ACE_Str_Buf.

ssize_t recv (void *buf, size_t len)
 Receive a message based on buffer pointer and maximum size.

void dump (void) const
 Dump the state of an object.


Public Attributes

 ACE_ALLOC_HOOK_DECLARE
 Declare the dynamic allocation hooks.

Detailed Description

Receiver side for the record oriented C++ wrapper for UNIX FIFOs.

This method works slightly differently on platforms with the ACE_HAS_STREAM_PIPES configuration setting than those without. With ACE_HAS_STREAM_PIPES, the getmsg() system function is used and it preserves message boundaries internally. Without ACE_HAS_STREAM_PIPES, the message boundaries are emulated by this class and ACE_FIFO_Send_Msg cooperating. The sending class first writes an integer number of bytes in the message, then the message. ACE_FIFO_Recv_Msg reads the count, then the data. The operational differences occur primarily when a message is larger than what a caller of this class requests. See recv() for details.

Definition at line 45 of file FIFO_Recv_Msg.h.

Constructor & Destructor Documentation

ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg (  void   ) 
 

Default constructor.

Definition at line 46 of file FIFO_Recv_Msg.cpp.

References ACE_TRACE. 

00047 {
00048   ACE_TRACE ("ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg");
00049 }

ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg (  const ACE_TCHAR *  rendezvous,
int  flags = O_CREAT|O_RDONLY,
mode_t  perms = ACE_DEFAULT_FILE_PERMS,
int  persistent = 1,
LPSECURITY_ATTRIBUTES  sa = 0
) 
 

Open up a record-oriented named pipe for reading.

Definition at line 51 of file FIFO_Recv_Msg.cpp.

References ACE_ERROR, ACE_TCHAR, ACE_TEXT, ACE_TRACE, LM_ERROR, mode_t, and open(). 

00056 {
00057   ACE_TRACE ("ACE_FIFO_Recv_Msg::ACE_FIFO_Recv_Msg");
00058 
00059   if (this->ACE_FIFO_Recv_Msg::open (fifo_name,
00060                                      flags,
00061                                      perms,
00062                                      persistent,
00063                                      sa) == -1)
00064     ACE_ERROR ((LM_ERROR,  ACE_TEXT ("%p\n"),  ACE_TEXT ("ACE_FIFO_Recv_Msg")));
00065 }

Member Function Documentation

ACE_BEGIN_VERSIONED_NAMESPACE_DECL void ACE_FIFO_Recv_Msg::dump (  void   )  const
 

Dump the state of an object.

Reimplemented from ACE_FIFO_Recv.

Definition at line 18 of file FIFO_Recv_Msg.cpp.

References ACE_TRACE, and ACE_FIFO_Recv::dump(). 

00019 {
00020 #if defined (ACE_HAS_DUMP)
00021   ACE_TRACE ("ACE_FIFO_Recv_Msg::dump");
00022   ACE_FIFO_Recv::dump ();
00023 #endif /* ACE_HAS_DUMP */
00024 }

int ACE_FIFO_Recv_Msg::open (  const ACE_TCHAR *  rendezvous,
int  flags = O_CREAT|O_RDONLY,
mode_t  perms = ACE_DEFAULT_FILE_PERMS,
int  persistent = 1,
LPSECURITY_ATTRIBUTES  sa = 0
) 
 

Open up a record-oriented named pipe for reading.

Reimplemented from ACE_FIFO_Recv.

Definition at line 31 of file FIFO_Recv_Msg.cpp.

References ACE_TCHAR, ACE_TRACE, mode_t, and ACE_FIFO_Recv::open().

Referenced by ACE_FIFO_Recv_Msg(). 

00036 {
00037   ACE_TRACE ("ACE_FIFO_Recv_Msg::open");
00038 
00039   return ACE_FIFO_Recv::open (fifo_name,
00040                               flags,
00041                               perms,
00042                               persistent,
00043                               sa);
00044 }

ACE_INLINE ssize_t ACE_FIFO_Recv_Msg::recv (  void *  buf,
size_t  len
) 
 

Receive a message based on buffer pointer and maximum size.

Parameters:
buf Pointer to the memory to receive the data.
len The maximum number of bytes to receive.
Return values:
-1 Error; consult errno for specific error number.
Returns:
The number of bytes received in the message. For messages that are larger than the requested maximum size, the behavior is different depending on the ACE_HAS_STREAM_PIPES configuration setting. With ACE_HAS_STREAM_PIPES, the return value will be the same as
  • len (this is also possible if the message is exactly the same length as
  • len, and the two cases are indistinguishable). Without ACE_HAS_STREAM_PIPES, the return value is the total length of the message, including bytes in excess of
  • len. The excess bytes are discarded.

Reimplemented from ACE_FIFO_Recv.

Definition at line 69 of file FIFO_Recv_Msg.inl.

References ACE_TRACE, and recv(). 

00070 {
00071   ACE_TRACE ("ACE_FIFO_Recv_Msg::recv");
00072   ACE_Str_Buf recv_msg ((char *) buf, 0, static_cast<int> (max_len));
00073 
00074   return this->recv (recv_msg);
00075 }

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ssize_t ACE_FIFO_Recv_Msg::recv (  ACE_Str_Buf &  msg  ) 
 

Receive a message based on attributes in an ACE_Str_Buf.

Parameters:
msg Reference to an ACE_Str_Buf whose buf member points to the memory to receive the data and maxlen member contains the maximum number of bytes to receive. On return after successfully reading data, the len member contains the number of bytes received and placed in the buffer pointed to by msg.buf.
Return values:
-1 Error; consult errno for specific error number.
Returns:
If the ACE_HAS_STREAM_PIPES configuration setting is defined, the return value is the number of bytes received in the message and will be the same as buf.len. The return value from the getmsg() system function is discarded. If ACE_HAS_STREAM_PIPES is not defined, the number of bytes in the message read from the FIFO is returned. If the message is larger than the maximum length requested in msg.maxlen, the return value reflects the entire message length, and the msg.len member reflects how many bytes were actually placed in the caller's buffer. Any part of the message longer than msg.maxlen is discarded.

Definition at line 15 of file FIFO_Recv_Msg.inl.

References ACE_MIN, ACE_TRACE, strbuf::buf, ACE_OS::getmsg(), strbuf::len, strbuf::maxlen, ACE_OS::read(), and ssize_t.

Referenced by recv(). 

00016 {
00017   ACE_TRACE ("ACE_FIFO_Recv_Msg::recv");
00018 #if defined (ACE_HAS_STREAM_PIPES)
00019   int i = 0;
00020   if (ACE_OS::getmsg (this->get_handle (),
00021                       (strbuf *) 0,
00022                       (strbuf *) &recv_msg,
00023                       &i) == -1)
00024     return -1;
00025   else
00026     return recv_msg.len;
00027 #else /* Do the ol' 2-read trick... */
00028   if (ACE_OS::read (this->get_handle (),
00029                     (char *) &recv_msg.len,
00030                     sizeof recv_msg.len) != sizeof recv_msg.len)
00031     return -1;
00032   else
00033     {
00034       size_t remaining = static_cast<size_t> (recv_msg.len);
00035       size_t requested = static_cast<size_t> (recv_msg.maxlen);
00036       ssize_t recv_len = ACE_OS::read (this->get_handle (),
00037                                        (char *) recv_msg.buf,
00038                                        ACE_MIN (remaining, requested));
00039       if (recv_len == -1)
00040         return -1;
00041       // Tell caller what's really in the buffer.
00042       recv_msg.len = static_cast<int> (recv_len);
00043 
00044       // If there are more bytes remaining in the message, read them and
00045       // throw them away. Leaving them in the FIFO would make it difficult
00046       // to find the start of the next message in the fifo.
00047       // Since the ACE_HAS_STREAM_PIPES version of this method doesn't
00048       // return getmsg()'s indication of "data remaining", don't worry about
00049       // saving the indication here either to read the remainder later.
00050       size_t total_msg_size = remaining;
00051       remaining -= recv_len;
00052       while (remaining > 0)
00053         {
00054           const size_t throw_away = 1024;
00055           char dev_null[throw_away];
00056           recv_len = ACE_OS::read (this->get_handle (),
00057                                    dev_null,
00058                                    ACE_MIN (remaining, throw_away));
00059           if (recv_len == -1)
00060             break;
00061           remaining -= recv_len;
00062         }
00063       return total_msg_size;
00064     }
00065 #endif /* ACE_HAS_STREAM_PIPES */
00066 }

Member Data Documentation

ACE_FIFO_Recv_Msg::ACE_ALLOC_HOOK_DECLARE
 

Declare the dynamic allocation hooks.

Reimplemented from ACE_FIFO_Recv.

Definition at line 128 of file FIFO_Recv_Msg.h.

The documentation for this class was generated from the following files:
Generated on Sun Jan 27 12:54:42 2008 for ACE by doxygen 1.3.6