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. More...
u_int | minor_version (void)
| e.g., the "1" in ACE 5.1.12. More...
u_int | beta_version (void)
| e.g., the "12" in ACE 5.1.12. Returns 0 for "stable" (non-beta) releases. More...
const ACE_TCHAR * | compiler_name (void)
| E.g., the "SunPro C++" in SunPro C++ 4.32.0. More...
u_int | compiler_major_version (void)
| E.g., the "4" in SunPro C++ 4.32.0. More...
u_int | compiler_minor_version (void)
| E.g., the "32" in SunPro C++ 4.32.0. More...
u_int | compiler_beta_version (void)
| E.g., the "0" in SunPro C++ 4.32.0. More...
int | out_of_handles (int error)
| Check if error indicates the process being out of handles (file descriptors). More...
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'. More...
char * | strnew (const char *s)
| This method is just like <strdup>, except that it uses <operator new> rather than <malloc>. If <s> is NULL returns NULL rather than segfaulting... More...
void | strdelete (char *s)
| Delete the memory allocated by <strnew>. More...
char * | strndup (const char *str, size_t n)
| Create a fresh new copy of <str>, up to <n> chars long. Uses <ACE_OS::malloc> to allocate the new string. More...
char * | strnnew (const char *str, size_t n)
| Create a fresh new copy of <str>, up to <n> chars long. Uses <ACE_OS::malloc> to allocate the new string. More...
const wchar_t * | strend (const wchar_t *s)
wchar_t * | strnew (const wchar_t *s)
void | strdelete (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. More...
size_t | round_to_allocation_granularity (off_t len)
| Rounds the request to a multiple of the allocation granularity. More...
size_t | format_hexdump (const char *buffer, size_t size, ACE_TCHAR *obuf, size_t obuf_sz)
| Format buffer into printable format. This is useful for debugging. More...
u_long | hash_pjw (const char *str)
| Computes the hash value of <str> using the "Hash PJW" routine. More...
u_long | hash_pjw (const char *str, size_t len)
| Computes the hash value of <str> using the "Hash PJW" routine. More...
u_long | hash_pjw (const wchar_t *str)
| Computes the hash value of <str> using the "Hash PJW" routine. More...
u_long | hash_pjw (const wchar_t *str, size_t len)
| Computes the hash value of <str> using the "Hash PJW" routine. More...
u_long | crc32 (const char *str)
| Computes the ISO 8802-3 standard 32 bits CRC for the string (not for a file). More...
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). More...
u_long | crc32 (iovec *iov, int len)
| Computes the ISO 8802-3 standard 32 bits CRC for the @ len iovec buffers. More...
u_long | gcd (u_long x, u_long y)
| Euclid's greatest common divisor algorithm. More...
u_long | minimum_frame_size (u_long period1, u_long period2)
| Calculates the minimum enclosing frame size for the given values. More...
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. More...
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... More...
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>. More...
ACE_TCHAR | nibble2hex (u_int n)
| Hex conversion utility. More...
u_char | hex2byte (ACE_TCHAR c)
| Convert a hex character to its byte representation. More...
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 <ACE_Handle_Set>s. More...
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 <ACE_Handle_Set>s. More...
int | handle_read_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get read ready. More...
int | handle_write_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get write ready. More...
int | handle_exception_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get exception ready. More...
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. More...
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. More...
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. More...
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. More...
void | restore_non_blocking_mode (ACE_HANDLE handle, int val)
| Cleanup after a timed operation, restore the appropriate non-blocking status of <handle>. More...
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,...)
| Receive into a variable number of pieces. More...
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. More...
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. More...
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. More...
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. More...
size_t | allocation_granularity_ = 0
| Size of allocation granularity. More...
u_long | crc_table_ []
| CRC table. More...
const ACE_TCHAR | hex_chars_ [] = ACE_LIB_TEXT ("0123456789abcdef")
| Hex characters. More...
char | debug_ = 0
| Are we debugging ACE? More...

## 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 | ( | iovec * | iov,
|  | int | len
| ) | `[static]`

| Computes the ISO 8802-3 standard 32 bits CRC for the @ len iovec buffers.

u_long ACE::crc32 | ( | const char * | buffer,
|  | 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 * | string | ) | `[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 * | old_name | ) | `[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 <avoid_zombies> == 0 call <ACE_OS::fork> 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.

size_t ACE::format_hexdump | ( | const char * | buffer,
|  | size_t | size,
|  | ACE_TCHAR * | obuf,
|  | size_t | 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 <accept>, it just does the timed wait...

ACE_HANDLE ACE::handle_timed_complete | ( | ACE_HANDLE | h,
|  | 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 <ACE::set_handle_limit>.

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 * | bt = 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]`

  | Receive into a variable number of pieces. Accepts a variable, caller-specified, number of pointer/length pairs. Arguments following n are char *, size_t pairs. Parameters:
  handle | The I/O handle to receive on
  n | The total number of char *, size_t pairs following n.
Returns: -1 on error, else total number of bytes received.

ssize_t ACE::recv | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | n,
|  | 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 * | bt = 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 | len | ) | `[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 <ACE_Handle_Set>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 <ACE_Handle_Set>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 | n,
|  | const ACE_Time_Value * | timeout = 0
| ) | `[static]`

ssize_t ACE::send | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | n,
|  | 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 * | bt = 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...

void ACE::strdelete | ( | wchar_t * | s | ) | `[static]`

void ACE::strdelete | ( | char * | s | ) | `[static]`

| Delete the memory allocated by <strnew>.

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 <ACE_OS::malloc> and must be freed by <ACE_OS::free>.

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 <ACE_OS::malloc> to allocate the new string.

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

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

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

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 <ACE_OS::malloc> 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 | n,
|  | 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 | date_and_timelen,
|  | 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, which is a user-supplied array of size <time_len> <ACE_TCHAR>s. Returns 0 if unsuccessful, else returns pointer to beginning of the "time" portion of <date_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 * | bt = 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 * | i,
|  | int | iovcnt,
|  | size_t * | bt = 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`[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