Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE Class Reference

Contains value added ACE methods that extend the behavior of the UNIX and Win32 OS calls. More...

`#include <ACE.h>`

Inheritance diagram for ACE

[legend]
Collaboration diagram for ACE:

[legend]
List of all members.

## Static Public Methods
u_int | major_version (void)
| e.g., the "5" in ACE 5.1.12.
u_int | minor_version (void)
| e.g., the "1" in ACE 5.1.12.
u_int | beta_version (void)
| e.g., the "12" in ACE 5.1.12. Returns 0 for "stable" (non-beta) releases.
const ACE_TCHAR* | compiler_name (void)
| E.g., the "SunPro C++" in SunPro C++ 4.32.0.
u_int | compiler_major_version (void)
| E.g., the "4" in SunPro C++ 4.32.0.
u_int | compiler_minor_version (void)
| E.g., the "32" in SunPro C++ 4.32.0.
u_int | compiler_beta_version (void)
| E.g., the "0" in SunPro C++ 4.32.0.
int | out_of_handles (int error)
| Check if error indicates the process being out of handles (file descriptors).
int | handle_timed_accept (ACE_HANDLE listener, ACE_Time_Value *timeout, int restart)
ACE_HANDLE | handle_timed_complete (ACE_HANDLE listener, const ACE_Time_Value *timeout, int is_tli = 0)
int | set_handle_limit (int new_limit = -1)
int | max_handles (void)
ACE_TCHAR* | strenvdup (const ACE_TCHAR *str)
const char* | strend (const char *s)
| Returns a pointer to the "end" of the string, i.e., the character past the '\0'.
char* | strnew (const char *s)
| This method is just like <strdup>, except that it uses <operator new> rather than <malloc>.
char* | strndup (const char *str, size_t n)
| Create a fresh new copy of <str>, up to <n> chars long. Uses to allocate the new string.
char* | strnnew (const char *str, size_t n)
| Create a fresh new copy of <str>, up to <n> chars long. Uses to allocate the new string.
const wchar_t* | strend (const wchar_t *s)
wchar_t* | strnew (const wchar_t *s)
wchar_t* | strndup (const wchar_t *str, size_t n)
wchar_t* | strnnew (const wchar_t *str, size_t n)
const ACE_TCHAR* | execname (const ACE_TCHAR *pathname)
const ACE_TCHAR* | basename (const ACE_TCHAR *pathname, ACE_TCHAR delim = ACE_DIRECTORY_SEPARATOR_CHAR)
const ACE_TCHAR* | dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim = ACE_DIRECTORY_SEPARATOR_CHAR)
ACE_TCHAR* | timestamp (ACE_TCHAR date_and_time[], int time_len, int return_pointer_to_first_digit = 0)
pid_t | fork (const ACE_TCHAR *program_name = ACE_LIB_TEXT ("<unknown>"), int avoid_zombies = 0)
int | daemonize (const ACE_TCHAR pathname[] = ACE_LIB_TEXT ("/"), int close_all_handles = ACE_DEFAULT_CLOSE_ALL_HANDLES, const ACE_TCHAR program_name[] = ACE_LIB_TEXT ("<unknown>"))
size_t | round_to_pagesize (off_t length)
| Rounds the request to a multiple of the page size.
size_t | round_to_allocation_granularity (off_t len)
| Rounds the request to a multiple of the allocation granularity.
int | format_hexdump (const char *buffer, int size, ACE_TCHAR *obuf, int obuf_sz)
| Format buffer into printable format. This is useful for debugging.
u_long | hash_pjw (const char *str)
| Computes the hash value of <str> using the "Hash PJW" routine.
u_long | hash_pjw (const char *str, size_t len)
| Computes the hash value of <str> using the "Hash PJW" routine.
u_long | hash_pjw (const wchar_t *str)
| Computes the hash value of <str> using the "Hash PJW" routine.
u_long | hash_pjw (const wchar_t *str, size_t len)
| Computes the hash value of <str> using the "Hash PJW" routine.
u_long | crc32 (const char *str)
| Computes the ISO 8802-3 standard 32 bits CRC for the string (not for a file).
u_long | crc32 (const char *buf, ACE_UINT32 len)
| Computes the ISO 8802-3 standard 32 bits CRC for the given buffer (the length is included in the CRC).
u_long | gcd (u_long x, u_long y)
| Euclid's greatest common divisor algorithm.
u_long | minimum_frame_size (u_long period1, u_long period2)
| Calculates the minimum enclosing frame size for the given values.
u_long | is_prime (const u_long n, const u_long min_factor, const u_long max_factor)
int | map_errno (int error)
| Map troublesome win32 errno values to values that standard C strerr function understands. Thank you Microsoft.
const ACE_TCHAR* | sock_error (int error)
| Returns a string containing the error message corresponding to a WinSock error. This works around an omission in the Win32 API...
int | process_active (pid_t pid)
int | terminate_process (pid_t pid)
void | unique_name (const void *object, ACE_TCHAR *name, size_t length)
u_long | log2 (u_long num)
| Computes the base 2 logarithm of <num>.
ACE_TCHAR | nibble2hex (u_int n)
| Hex conversion utility.
u_char | hex2byte (ACE_TCHAR c)
| Convert a hex character to its byte representation.
char | debug (void)
void | debug (char d)
int | select (int width, ACE_Handle_Set *readfds, ACE_Handle_Set *writefds = 0, ACE_Handle_Set *exceptfds = 0, const ACE_Time_Value *timeout = 0)
| Wrapper facade for <select> that uses s.
int | select (int width, ACE_Handle_Set &readfds, const ACE_Time_Value *timeout = 0)
| Wrapper facade for the most common use of <select> that uses s.
int | handle_read_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get read ready.
int | handle_write_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get write ready.
int | handle_exception_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get exception ready.
int | handle_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout, int read_ready, int write_ready, int exception_ready)
| Timed wait for handle to get read, write, or exception ready.
int | enter_recv_timedwait (ACE_HANDLE handle, const ACE_Time_Value *timeout, int &val)
| Wait for <timeout> before proceeding to a <recv> operation. <val> keeps track of whether we're in non-blocking mode or not.
int | enter_send_timedwait (ACE_HANDLE handle, const ACE_Time_Value* timeout, int &val)
| Wait for <timeout> before proceeding to a <send> operation. <val> keeps track of whether we're in non-blocking mode or not.
void | record_and_set_non_blocking_mode (ACE_HANDLE handle, int &val)
| This makes sure that <handle> is set into non-blocking mode. <val> keeps track of whether were in non-blocking mode or not.
void | restore_non_blocking_mode (ACE_HANDLE handle, int val)
| Cleanup after a timed operation, restore the appropriate non-blocking status of <handle>.
I/O operations
Notes on common parameters: <handle> is the connected endpoint that will be used for I/O. <buf> is the buffer to write from or receive into. <len> is the number of bytes to transfer. The <timeout> parameter in the following methods indicates how long to blocking trying to transfer data. If <timeout> == 0, then the call behaves as a normal send/recv call, i.e., for blocking sockets, the call will block until action is possible; for non-blocking sockets, EWOULDBLOCK will be returned if no action is immediately possible. If <timeout> != 0, the call will wait until the relative time specified in *<timeout> elapses. The "_n()" I/O methods keep looping until all the data has been transferred. These methods also work for sockets in non-blocking mode i.e., they keep looping on EWOULDBLOCK. <timeout> is used to make sure we keep making progress, i.e., the same timeout value is used for every I/O operation in the loop and the timeout is not counted down. The return values for the "*_n()" methods match the return values from the non "_n()" methods and are specified as follows: On complete transfer, the number of bytes transferred is returned. On timeout, -1 is returned, errno == ETIME. On error, -1 is returned, errno is set to appropriate error. On EOF, 0 is returned, errno is irrelevant. On partial transfers, i.e., if any data is transferred before timeout/error/EOF, <bytes_transferred> will contain the number of bytes transferred. Methods with <iovec> parameter are I/O vector variants of the I/O operations. Methods with the extra <flags> argument will always result in <send> getting called. Methods without the extra <flags> argument will result in <send> getting called on Win32 platforms, and <write> getting called on non-Win32 platforms.
ssize_t | recv (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout = 0)
ssize_t | t_rcv (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout = 0)
ssize_t | recv (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout = 0)
ssize_t | recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags, const ACE_Time_Value *timeout = 0)
ssize_t | recvfrom (ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen, const ACE_Time_Value *timeout = 0)
ssize_t | recv_n (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | t_rcv_n (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | recv_n (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | recv (ACE_HANDLE handle, size_t n, ...)
| Varargs variant.
ssize_t | recvv (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout = 0)
ssize_t | recvv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | recv_n (ACE_HANDLE handle, ACE_Message_Block *message_block, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | send (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout = 0)
ssize_t | t_snd (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout = 0)
ssize_t | send (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout = 0)
ssize_t | sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags, const ACE_Time_Value *timeout = 0)
ssize_t | sendto (ACE_HANDLE handle, const char *buf, int len, int flags, const struct sockaddr *addr, int addrlen, const ACE_Time_Value *timeout = 0)
ssize_t | send_n (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | t_snd_n (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | send_n (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | send (ACE_HANDLE handle, size_t n, ...)
| Varargs variant.
ssize_t | sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout = 0)
ssize_t | sendv_n (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
ssize_t | send_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, const ACE_Time_Value *timeout = 0, size_t *bytes_transferred = 0)
| Send all the <message_block>s chained through their <next> and <cont> pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty.
ssize_t | read_n (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred = 0)
ssize_t | write_n (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred = 0)
ssize_t | write_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, size_t *bytes_transferred = 0)
| Write all the <message_block>s chained through their <next> and <cont> pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty.
ssize_t | readv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bytes_transferred = 0)
ssize_t | writev_n (ACE_HANDLE handle, const iovec *iov, int iovcnt, size_t *bytes_transferred = 0)
## Private Methods
| ACE_CLASS_IS_NAMESPACE (ACE)
## Static Private Methods
ssize_t | recv_i (ACE_HANDLE handle, void *buf, size_t len)
ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, size_t *bytes_transferred)
ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, size_t *bytes_transferred)
ssize_t | t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred)
ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bytes_transferred)
ssize_t | recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | send_i (ACE_HANDLE handle, const void *buf, size_t len)
ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bytes_transferred)
ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bytes_transferred)
ssize_t | t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred)
ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ssize_t | sendv_n_i (ACE_HANDLE handle, const iovec *iov, int iovcnt, size_t *bytes_transferred)
ssize_t | sendv_n_i (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bytes_transferred)
## Static Private Attributes
size_t | pagesize_ = 0
| Size of a VM page.
size_t | allocation_granularity_ = 0
| Size of allocation granularity.
u_long | crc_table_ []
| CRC table.
const ACE_TCHAR | hex_chars_ [] = ACE_LIB_TEXT ("0123456789abcdef")
| Hex characters.
char | debug_ = 0
| Are we debugging ACE?

## Detailed Description

Contains value added ACE methods that extend the behavior of the UNIX and Win32 OS calls.

This class consolidates all these ACE static methods in a single place in order to manage the namespace better. These methods are put here rather than in ACE_OS in order to separate concerns.

## Member Function Documentation

ACE::ACE_CLASS_IS_NAMESPACE ( | ACE )`[private]`

const ACE_TCHAR * ACE::basename ( | const ACE_TCHAR * pathname,
| ACE_TCHAR delim = ACE_DIRECTORY_SEPARATOR_CHAR )`[static]`

| Returns the "basename" of a <pathname> separated by <delim>. For instance, the basename of "/tmp/foo.cpp" is "foo.cpp" when <delim> is '/'.

u_int ACE::beta_version ( | void )`[static]`

| e.g., the "12" in ACE 5.1.12. Returns 0 for "stable" (non-beta) releases.

u_int ACE::compiler_beta_version ( | void )`[static]`

| E.g., the "0" in SunPro C++ 4.32.0.

u_int ACE::compiler_major_version ( | void )`[static]`

| E.g., the "4" in SunPro C++ 4.32.0.

u_int ACE::compiler_minor_version ( | void )`[static]`

| E.g., the "32" in SunPro C++ 4.32.0.

const ACE_TCHAR * ACE::compiler_name ( | void )`[static]`

| E.g., the "SunPro C++" in SunPro C++ 4.32.0.

u_long ACE::crc32 ( | const char * buf,
| ACE_UINT32 len )`[static]`

| Computes the ISO 8802-3 standard 32 bits CRC for the given buffer (the length is included in the CRC).

u_long ACE::crc32 ( | const char * str )`[static]`

| Computes the ISO 8802-3 standard 32 bits CRC for the string (not for a file).

int ACE::daemonize ( | const ACE_TCHAR pathname[] = ACE_LIB_TEXT ("/"),
| int close_all_handles = ACE_DEFAULT_CLOSE_ALL_HANDLES,
| const ACE_TCHAR program_name[] = ACE_LIB_TEXT ("<unknown>") )`[static]`

| Become a daemon process using the algorithm in Richard Stevens "Advanced Programming in the UNIX Environment." If <close_all_handles> is non-zero then all open file handles are closed.

ASYS_INLINE void ACE::debug ( | char c )`[static]`

ASYS_INLINE char ACE::debug ( | void )`[static]`

const ACE_TCHAR * ACE::dirname ( | const ACE_TCHAR * pathname,
| ACE_TCHAR delim = ACE_DIRECTORY_SEPARATOR_CHAR )`[static]`

| Returns the "dirname" of a <pathname>. For instance, the dirname of "/tmp/foo.cpp" is "/tmp" when <delim> is '/'. If <pathname> has no <delim> ".\0" is returned. This method does not modify <pathname> and is not reentrant.

int ACE::enter_recv_timedwait ( | ACE_HANDLE handle,
| const ACE_Time_Value * timeout,
| int & val )`[static]`

| Wait for <timeout> before proceeding to a <recv> operation. <val> keeps track of whether we're in non-blocking mode or not.

int ACE::enter_send_timedwait ( | ACE_HANDLE handle,
| const ACE_Time_Value * timeout,
| int & val )`[static]`

| Wait for <timeout> before proceeding to a <send> operation. <val> keeps track of whether we're in non-blocking mode or not.

const ACE_TCHAR * ACE::execname ( | const ACE_TCHAR * pathname )`[static]`

| On Win32 returns <pathname> if it already ends in ".exe," otherwise returns a dynamically allocated buffer containing "<pathname>.exe". Always returns <pathname> on UNIX.

pid_t ACE::fork ( | const ACE_TCHAR * program_name = ACE_LIB_TEXT ("<unknown>"),
| int avoid_zombies = 0 )`[static]`

| if == 0 call directly, else create an orphan process that's inherited by the init process; init cleans up when the orphan process terminates so we don't create zombies.

int ACE::format_hexdump ( | const char * buffer,
| int size,
| ACE_TCHAR * obuf,
| int obuf_sz )`[static]`

| Format buffer into printable format. This is useful for debugging.

u_long ACE::gcd ( | u_long x,
| u_long y )`[static]`

| Euclid's greatest common divisor algorithm.

ASYS_INLINE int ACE::handle_exception_ready ( | ACE_HANDLE handle,
| const ACE_Time_Value * timeout )`[static]`

| Timed wait for handle to get exception ready.

ASYS_INLINE int ACE::handle_read_ready ( | ACE_HANDLE handle,
| const ACE_Time_Value * timeout )`[static]`

| Timed wait for handle to get read ready.

int ACE::handle_ready ( | ACE_HANDLE handle,
| const ACE_Time_Value * timeout,
| int read_ready,
| int write_ready,
| int exception_ready )`[static]`

| Timed wait for handle to get read, write, or exception ready.

int ACE::handle_timed_accept ( | ACE_HANDLE listener,
| ACE_Time_Value * timeout,
| int restart )`[static]`

| Wait up to <timeout> amount of time to passively establish a connection. This method doesn't perform the , it just does the timed wait...

ACE_HANDLE ACE::handle_timed_complete ( | ACE_HANDLE listener,
| const ACE_Time_Value * timeout,
| int is_tli = 0 )`[static]`

| Wait up to <timeout> amount of time to complete an actively established non-blocking connection. If <is_tli> is non-0 then we are being called by a TLI wrapper (which behaves slightly differently from a socket wrapper).

ASYS_INLINE int ACE::handle_write_ready ( | ACE_HANDLE handle,
| const ACE_Time_Value * timeout )`[static]`

| Timed wait for handle to get write ready.

u_long ACE::hash_pjw ( | const wchar_t * str,
| size_t len )`[static]`

| Computes the hash value of <str> using the "Hash PJW" routine.

u_long ACE::hash_pjw ( | const wchar_t * str )`[static]`

| Computes the hash value of <str> using the "Hash PJW" routine.

u_long ACE::hash_pjw ( | const char * str,
| size_t len )`[static]`

| Computes the hash value of <str> using the "Hash PJW" routine.

u_long ACE::hash_pjw ( | const char * str )`[static]`

| Computes the hash value of <str> using the "Hash PJW" routine.

ASYS_INLINE u_char ACE::hex2byte ( | ACE_TCHAR c )`[static]`

| Convert a hex character to its byte representation.

u_long ACE::is_prime ( | const u_long n,
| const u_long min_factor,
| const u_long max_factor )`[static]`

| Function that can burn up noticeable CPU time: brute-force determination of whether number "n" is prime. Returns 0 if it is prime, or the smallest factor if it is not prime. min_factor and max_factor can be used to partition the work among threads. For just one thread, typical values are 2 and n/2.

ASYS_INLINE u_long ACE::log2 ( | u_long num )`[static]`

| Computes the base 2 logarithm of <num>.

u_int ACE::major_version ( | void )`[static]`

| e.g., the "5" in ACE 5.1.12.

int ACE::map_errno ( | int error )`[static]`

| Map troublesome win32 errno values to values that standard C strerr function understands. Thank you Microsoft.

int ACE::max_handles ( | void )`[static]`

| Returns the maximum number of open handles currently permitted in this process. This maximum may be extended using .

u_long ACE::minimum_frame_size ( | u_long period1,
| u_long period2 )`[static]`

| Calculates the minimum enclosing frame size for the given values.

u_int ACE::minor_version ( | void )`[static]`

| e.g., the "1" in ACE 5.1.12.

ASYS_INLINE ACE_TCHAR ACE::nibble2hex ( | u_int n )`[static]`

| Hex conversion utility.

int ACE::out_of_handles ( | int error )`[static]`

| Check if error indicates the process being out of handles (file descriptors).

int ACE::process_active ( | pid_t pid )`[static]`

| Checks if process with <pid> is still alive. Returns 1 if it is still alive, 0 if it isn't alive, and -1 if something weird happened.

ASYS_INLINE ssize_t ACE::read_n ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::readv_n ( | ACE_HANDLE handle,
| iovec * iov,
| int iovcnt,
| size_t * bytes_transferred = 0 )`[static]`

void ACE::record_and_set_non_blocking_mode ( | ACE_HANDLE handle,
| int & val )`[static]`

| This makes sure that <handle> is set into non-blocking mode. <val> keeps track of whether were in non-blocking mode or not.

ssize_t ACE::recv ( | ACE_HANDLE handle,
| size_t n,
| ... )`[static]`

| Varargs variant.

ssize_t ACE::recv ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::recv ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout = 0 )`[static]`

ASYS_INLINE ssize_t ACE::recv_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len )`[static, private]`

ssize_t ACE::recv_n ( | ACE_HANDLE handle,
| ACE_Message_Block * message_block,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ASYS_INLINE ssize_t ACE::recv_n ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ASYS_INLINE ssize_t ACE::recv_n ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::recv_n_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::recv_n_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| size_t * bt )`[static, private]`

ssize_t ACE::recv_n_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::recv_n_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int flags,
| size_t * bt )`[static, private]`

ssize_t ACE::recvfrom ( | ACE_HANDLE handle,
| char * buf,
| int len,
| int flags,
| struct sockaddr * addr,
| int * addrlen,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::recvmsg ( | ACE_HANDLE handle,
| struct msghdr * msg,
| int flags,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::recvv ( | ACE_HANDLE handle,
| iovec * iov,
| int iovcnt,
| const ACE_Time_Value * timeout = 0 )`[static]`

ASYS_INLINE ssize_t ACE::recvv_n ( | ACE_HANDLE handle,
| iovec * iov,
| int iovcnt,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::recvv_n_i ( | ACE_HANDLE handle,
| iovec * iov,
| int iovcnt,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::recvv_n_i ( | ACE_HANDLE handle,
| iovec * iov,
| int iovcnt,
| size_t * bt )`[static, private]`

void ACE::restore_non_blocking_mode ( | ACE_HANDLE handle,
| int val )`[static]`

| Cleanup after a timed operation, restore the appropriate non-blocking status of <handle>.

size_t ACE::round_to_allocation_granularity ( | off_t len )`[static]`

| Rounds the request to a multiple of the allocation granularity.

size_t ACE::round_to_pagesize ( | off_t length )`[static]`

| Rounds the request to a multiple of the page size.

int ACE::select ( | int width,
| ACE_Handle_Set & readfds,
| const ACE_Time_Value * timeout = 0 )`[static]`

| Wrapper facade for the most common use of <select> that uses s.

int ACE::select ( | int width,
| ACE_Handle_Set * readfds,
| ACE_Handle_Set * writefds = 0,
| ACE_Handle_Set * exceptfds = 0,
| const ACE_Time_Value * timeout = 0 )`[static]`

| Wrapper facade for <select> that uses s.

ssize_t ACE::send ( | ACE_HANDLE handle,
| size_t n,
| ... )`[static]`

| Varargs variant.

ssize_t ACE::send ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::send ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout = 0 )`[static]`

ASYS_INLINE ssize_t ACE::send_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len )`[static, private]`

ssize_t ACE::send_n ( | ACE_HANDLE handle,
| const ACE_Message_Block * message_block,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

| Send all the <message_block>s chained through their <next> and <cont> pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty.

ASYS_INLINE ssize_t ACE::send_n ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ASYS_INLINE ssize_t ACE::send_n ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::send_n_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::send_n_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| size_t * bt )`[static, private]`

ssize_t ACE::send_n_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::send_n_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| size_t * bt )`[static, private]`

ssize_t ACE::sendmsg ( | ACE_HANDLE handle,
| const struct msghdr * msg,
| int flags,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::sendto ( | ACE_HANDLE handle,
| const char * buf,
| int len,
| int flags,
| const struct sockaddr * addr,
| int addrlen,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::sendv ( | ACE_HANDLE handle,
| const iovec * iov,
| int iovcnt,
| const ACE_Time_Value * timeout = 0 )`[static]`

ASYS_INLINE ssize_t ACE::sendv_n ( | ACE_HANDLE handle,
| const iovec * iov,
| int iovcnt,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::sendv_n_i ( | ACE_HANDLE handle,
| const iovec * i,
| int iovcnt,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::sendv_n_i ( | ACE_HANDLE handle,
| const iovec * i,
| int iovcnt,
| size_t * bt )`[static, private]`

int ACE::set_handle_limit ( | int new_limit = -1 )`[static]`

| Reset the limit on the number of open handles. If <new_limit> == -1 set the limit to the maximum allowable. Otherwise, set it to be the value of <new_limit>.

const ACE_TCHAR * ACE::sock_error ( | int error )`[static]`

| Returns a string containing the error message corresponding to a WinSock error. This works around an omission in the Win32 API...

const wchar_t * ACE::strend ( | const wchar_t * s )`[static]`

const char * ACE::strend ( | const char * s )`[static]`

| Returns a pointer to the "end" of the string, i.e., the character past the '\0'.

ACE_TCHAR * ACE::strenvdup ( | const ACE_TCHAR * str )`[static]`

| Return a dynamically allocated duplicate of <str>, substituting the environment variable if <str[0] == '$'>. Note that the pointer is allocated with and must be freed by .

wchar_t * ACE::strndup ( | const wchar_t * str,
| size_t n )`[static]`

char * ACE::strndup ( | const char * str,
| size_t n )`[static]`

| Create a fresh new copy of <str>, up to <n> chars long. Uses to allocate the new string.

wchar_t* ACE::strnew ( | const wchar_t * s )`[static]`

ASYS_INLINE char * ACE::strnew ( | const char * s )`[static]`

| This method is just like <strdup>, except that it uses <operator new> rather than <malloc>.

wchar_t * ACE::strnnew ( | const wchar_t * str,
| size_t n )`[static]`

char * ACE::strnnew ( | const char * str,
| size_t n )`[static]`

| Create a fresh new copy of <str>, up to <n> chars long. Uses to allocate the new string.

ssize_t ACE::t_rcv ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int * flags,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::t_rcv_n ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int * flags,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::t_rcv_n_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int * flags,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::t_rcv_n_i ( | ACE_HANDLE handle,
| void * buf,
| size_t len,
| int * flags,
| size_t * bt )`[static, private]`

ssize_t ACE::t_snd ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout = 0 )`[static]`

ssize_t ACE::t_snd_n ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout = 0,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::t_snd_n_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| const ACE_Time_Value * timeout,
| size_t * bt )`[static, private]`

ssize_t ACE::t_snd_n_i ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| int flags,
| size_t * bt )`[static, private]`

int ACE::terminate_process ( | pid_t pid )`[static]`

| Terminate the process abruptly with id <pid>. On Win32 platforms this uses <TerminateProcess> and on POSIX platforms is uses <kill> with the -9 (SIGKILL) signal, which cannot be caught or ignored. Note that this call is potentially dangerous to use since the process being terminated may not have a chance to cleanup before it shuts down.

ACE_TCHAR * ACE::timestamp ( | ACE_TCHAR date_and_time[],
| int time_len,
| int return_pointer_to_first_digit = 0 )`[static]`

| Returns the current timestamp in the form "hour:minute:second:microsecond." The month, day, and year are also stored in the beginning of the date_and_time array. Returns 0 if unsuccessful, else returns pointer to beginning of the "time" portion of <day_and_time>. If <return_pointer_to_first_digit> is 0 then return a pointer to the space before the time, else return a pointer to the beginning of the time portion.

ASYS_INLINE void ACE::unique_name ( | const void * object,
| ACE_TCHAR * name,
| size_t length )`[static]`

| This method uses process id and object pointer to come up with a machine wide unique name. The process ID will provide uniqueness between processes on the same machine. The "this" pointer of the <object> will provide uniqueness between other "live" objects in the same process. The uniqueness of this name is therefore only valid for the life of <object>.

ssize_t ACE::write_n ( | ACE_HANDLE handle,
| const ACE_Message_Block * message_block,
| size_t * bytes_transferred = 0 )`[static]`

| Write all the <message_block>s chained through their <next> and <cont> pointers. This call uses the underlying OS gather-write operation to reduce the domain-crossing penalty.

ASYS_INLINE ssize_t ACE::write_n ( | ACE_HANDLE handle,
| const void * buf,
| size_t len,
| size_t * bytes_transferred = 0 )`[static]`

ssize_t ACE::writev_n ( | ACE_HANDLE handle,
| const iovec * iov,
| int iovcnt,
| size_t * bytes_transferred = 0 )`[static]`

## Member Data Documentation

size_t ACE::allocation_granularity_ = 0`[static, private]`

| Size of allocation granularity.

u_long ACE::crc_table_[]`[static, private]`

| CRC table.

char ACE::debug_ = 0`[inline, static, private]`

| Are we debugging ACE?

const ACE_TCHAR ACE::hex_chars_[] = ACE_LIB_TEXT ("0123456789abcdef")`[static, private]`

| Hex characters.

size_t ACE::pagesize_ = 0`[static, private]`

| Size of a VM page.

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

- ACE.h
- ACE.cpp
- ACE.i