# ACE.h File Reference

`#include "ace/config-lite.h"`
`#include "ace/Flag_Manip.h"`
`#include "ace/Handle_Ops.h"`
`#include "ace/Lib_Find.h"`
`#include "ace/Init_ACE.h"`
`#include "ace/Sock_Connect.h"`
`#include "ace/Default_Constants.h"`
`#include "ace/ACE.inl"`

Include dependency graph for ACE.h:

This graph shows which files directly or indirectly include this file:

## Namespaces

namespace | ACE

## 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.

ACE_Export ssize_t | recv (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | t_rcv (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | recv (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | recvfrom (ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | recv_n (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t | recv (ACE_HANDLE handle, size_t n,...)
| Receive into a variable number of pieces.
ACE_Export ssize_t | recvv (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | recvv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t | recv_n (ACE_HANDLE handle, ACE_Message_Block *message_block, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t | send (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | t_snd (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | send (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout=0)
ACE_Export ssize_t | sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags, const ACE_Time_Value *timeout=0)
ACE_Export 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)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION 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)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | send_n (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t | send (ACE_HANDLE handle, size_t n,...)
| Varargs variant.
ACE_Export ssize_t | sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | sendv_n (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_Export ssize_t | send_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, const ACE_Time_Value *timeout=0, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | read_n (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred=0)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | write_n (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred=0)
ACE_Export ssize_t | write_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, size_t *bytes_transferred=0)
ACE_Export ssize_t | readv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bytes_transferred=0)
ACE_Export ssize_t | writev_n (ACE_HANDLE handle, const iovec *iov, int iovcnt, size_t *bytes_transferred=0)

## Defines

#define | ACE_EXPORT_MACRO ACE_Export

## Functions

ACE_Export u_int | major_version (void)
| e.g., the "5" in ACE 5.1.12.
ACE_Export u_int | minor_version (void)
| e.g., the "1" in ACE 5.1.12.
ACE_Export u_int | beta_version (void)
ACE_Export const ACE_TCHAR * | compiler_name (void)
| E.g., the "SunPro C++" in SunPro C++ 4.32.0.
ACE_Export u_int | compiler_major_version (void)
| E.g., the "4" in SunPro C++ 4.32.0.
ACE_Export u_int | compiler_minor_version (void)
| E.g., the "32" in SunPro C++ 4.32.0.
ACE_Export u_int | compiler_beta_version (void)
| E.g., the "0" in SunPro C++ 4.32.0.
ACE_Export int | out_of_handles (int error)
ACE_Export bool | wild_match (const char *s, const char *pattern, bool case_sensitive=true)
ACE_Export int | handle_timed_accept (ACE_HANDLE listener, ACE_Time_Value *timeout, int restart)
ACE_Export ACE_HANDLE | handle_timed_complete (ACE_HANDLE listener, const ACE_Time_Value *timeout, int is_tli=0)
ACE_Export int | set_handle_limit (int new_limit=-1, int increase_limit_only=0)
ACE_Export int | max_handles (void)
ACE_Export ACE_TCHAR * | strenvdup (const ACE_TCHAR *str)
ACE_Export const char * | strend (const char *s)
ACE_Export char * | strnew (const char *s)
ACE_NAMESPACE_INLINE_FUNCTION void | strdelete (char *s)
| Delete the memory allocated by `strnew`.
ACE_Export char * | strndup (const char *str, size_t n)
ACE_Export char * | strnnew (const char *str, size_t n)
ACE_Export const wchar_t * | strend (const wchar_t *s)
ACE_Export wchar_t * | strnew (const wchar_t *s)
ACE_NAMESPACE_INLINE_FUNCTION void | strdelete (wchar_t *s)
ACE_Export wchar_t * | strndup (const wchar_t *str, size_t n)
ACE_Export wchar_t * | strnnew (const wchar_t *str, size_t n)
ACE_Export const ACE_TCHAR * | execname (const ACE_TCHAR *pathname)
ACE_Export const ACE_TCHAR * | basename (const ACE_TCHAR *pathname, ACE_TCHAR delim=ACE_DIRECTORY_SEPARATOR_CHAR)
ACE_Export const ACE_TCHAR * | dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim=ACE_DIRECTORY_SEPARATOR_CHAR)
ACE_Export ACE_TCHAR * | timestamp (ACE_TCHAR date_and_time[], int time_len, int return_pointer_to_first_digit=0)
ACE_Export pid_t | fork (const ACE_TCHAR *program_name=ACE_LIB_TEXT("<unknown>"), int avoid_zombies=0)
ACE_Export 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>"))
ACE_Export size_t | round_to_pagesize (off_t length)
| Rounds the request to a multiple of the page size.
ACE_Export size_t | round_to_allocation_granularity (off_t len)
| Rounds the request to a multiple of the allocation granularity.
ACE_Export size_t | format_hexdump (const char *buffer, size_t size, ACE_TCHAR *obuf, size_t obuf_sz)
ACE_Export u_long | hash_pjw (const char *str)
| Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export u_long | hash_pjw (const char *str, size_t len)
| Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export u_long | hash_pjw (const wchar_t *str)
| Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export u_long | hash_pjw (const wchar_t *str, size_t len)
| Computes the hash value of {str} using the "Hash PJW" routine.
ACE_Export ACE_UINT16 | crc_ccitt (const char *str)
| Computes CRC-CCITT for the string.
ACE_Export ACE_UINT16 | crc_ccitt (const void *buf, size_t len, ACE_UINT16 crc=0)
| Computes CRC-CCITT for the buffer.
ACE_Export ACE_UINT16 | crc_ccitt (const iovec *iov, int len, ACE_UINT16 crc=0)
| Computes CRC-CCITT for the @ len iovec buffers.
ACE_Export ACE_UINT32 | crc32 (const char *str)
| Computes the ISO 8802-3 standard 32 bits CRC for the string.
ACE_Export ACE_UINT32 | crc32 (const void *buf, size_t len, ACE_UINT32 crc=0)
| Computes the ISO 8802-3 standard 32 bits CRC for the buffer.
ACE_Export ACE_UINT32 | crc32 (const iovec *iov, int len, ACE_UINT32 crc=0)
ACE_Export u_long | gcd (u_long x, u_long y)
| Euclid's greatest common divisor algorithm.
ACE_Export u_long | minimum_frame_size (u_long period1, u_long period2)
| Calculates the minimum enclosing frame size for the given values.
ACE_Export u_long | is_prime (const u_long n, const u_long min_factor, const u_long max_factor)
ACE_Export int | map_errno (int error)
ACE_Export const ACE_TCHAR * | sock_error (int error)
ACE_Export bool | is_sock_error (int error)
ACE_Export int | process_active (pid_t pid)
ACE_Export int | terminate_process (pid_t pid)
ACE_NAMESPACE_INLINE_FUNCTION void | unique_name (const void *object, ACE_TCHAR *name, size_t length)
ACE_NAMESPACE_INLINE_FUNCTION u_long | log2 (u_long num)
| Computes the base 2 logarithm of {num}.
ACE_NAMESPACE_INLINE_FUNCTION ACE_TCHAR | nibble2hex (u_int n)
| Hex conversion utility.
ACE_NAMESPACE_INLINE_FUNCTION u_char | hex2byte (ACE_TCHAR c)
| Convert a hex character to its byte representation.
ACE_Export char | debug (void)
ACE_Export void | debug (char d)
ACE_Export 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_Sets`.
ACE_Export int | select (int width, ACE_Handle_Set &readfds, const ACE_Time_Value *timeout=0)
ACE_NAMESPACE_INLINE_FUNCTION int | handle_read_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get read ready.
ACE_NAMESPACE_INLINE_FUNCTION int | handle_write_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get write ready.
ACE_NAMESPACE_INLINE_FUNCTION int | handle_exception_ready (ACE_HANDLE handle, const ACE_Time_Value *timeout)
| Timed wait for handle to get exception ready.
ACE_Export 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.
ACE_Export int | enter_recv_timedwait (ACE_HANDLE handle, const ACE_Time_Value *timeout, int &val)
ACE_Export int | enter_send_timedwait (ACE_HANDLE handle, const ACE_Time_Value *timeout, int &val)
ACE_Export void | record_and_set_non_blocking_mode (ACE_HANDLE handle, int &val)
ACE_Export void | restore_non_blocking_mode (ACE_HANDLE handle, int val)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | recv_i (ACE_HANDLE handle, void *buf, size_t len)
ACE_Export ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, size_t *bytes_transferred)
ACE_Export ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t | t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, size_t *bytes_transferred)
ACE_Export 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)
ACE_Export ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred)
ACE_Export ssize_t | recv_n_i (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t | recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bytes_transferred)
ACE_Export ssize_t | recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_NAMESPACE_INLINE_FUNCTION ssize_t | send_i (ACE_HANDLE handle, const void *buf, size_t len)
ACE_Export ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bytes_transferred)
ACE_Export 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)
ACE_Export ssize_t | t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bytes_transferred)
ACE_Export 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)
ACE_Export ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred)
ACE_Export ssize_t | send_n_i (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bytes_transferred)
ACE_Export ssize_t | sendv_n_i (ACE_HANDLE handle, const iovec *iov, int iovcnt, size_t *bytes_transferred)
ACE_Export ssize_t | sendv_n_i (ACE_HANDLE handle, const iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bytes_transferred)

## Detailed Description

Id
  ACE.h,v 4.154 2006/01/14 19:07:02 schmidt Exp

This file contains value added ACE functions that extend the behavior of the UNIX and Win32 OS calls.

All these ACE static functions are consolidated in a single place in order to manage the namespace better. These functions are put here rather than in `ACE_OS` in order to separate concerns.

Author:
  Douglas C. Schmidt <schmidt@cs.wustl.edu>

## Define Documentation

#define ACE_EXPORT_MACRO ACE_Export

## Function Documentation

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

| 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 |  | ) |

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

u_int ACE::compiler_beta_version | ( | void |  | ) |

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

u_int ACE::compiler_major_version | ( | void |  | ) |

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

u_int ACE::compiler_minor_version | ( | void |  | ) |

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

const ACE_TCHAR * ACE::compiler_name | ( | void |  | ) |

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

ACE_UINT32 ACE::crc32 | ( | const iovec * | iov,
|  | int | len,
|  | ACE_UINT32 | crc = `0`
| ) |

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

ACE_UINT32 ACE::crc32 | ( | const void * | buf,
|  | size_t | len,
|  | ACE_UINT32 | crc = `0`
| ) |

| Computes the ISO 8802-3 standard 32 bits CRC for the buffer.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_UINT32 ACE::crc32 | ( | const char * | str | ) |

| Computes the ISO 8802-3 standard 32 bits CRC for the string.

ACE_UINT16 ACE::crc_ccitt | ( | const iovec * | iov,
|  | int | len,
|  | ACE_UINT16 | crc = `0`
| ) |

| Computes CRC-CCITT for the @ len iovec buffers.

ACE_UINT16 ACE::crc_ccitt | ( | const void * | buf,
|  | size_t | len,
|  | ACE_UINT16 | crc = `0`
| ) |

| Computes CRC-CCITT for the buffer.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_UINT16 ACE::crc_ccitt | ( | const char * | str | ) |

| Computes CRC-CCITT for the string.

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>")`
| ) |

| 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.

void ACE::debug | ( | char | d | ) |

char ACE::debug | ( | void |  | ) |

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

| 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
| ) |

| 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
| ) |

| 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 | ) |

On Windows, determines if a specified pathname ends with ".exe" (not case sensitive). If on Windows and there is no ".exe" suffix, a new ACE_TCHAR array is allocated and a copy of `pathname` with the ".exe" suffix is copied into it. In this case, the caller is responsible for calling delete [] on the returned pointer.

Parameters:

  | pathname | The name to check for a proper suffix.

Return values:

  | @c | pathname if there is a proper suffix for Windows. This is always the return value for non-Windows platforms.
  | If | a suffix needs to be added, returns a pointer to new[] allocated memory containing the original `pathname` plus a ".exe" suffix. The caller is responsible for freeing the memory using delete [].

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

| 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. Returns -1 on failure and either the child PID on success if avoid_zombies == 0 or 1 on success if avoid_zombies != 0 (this latter behavior is a known bug that needs to be fixed).

size_t ACE::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.

u_long ACE::gcd | ( | u_long | x,
|  | u_long | y
| ) |

| Euclid's greatest common divisor algorithm.

ACE_INLINE int ACE::handle_exception_ready | ( | ACE_HANDLE | handle,
|  | const ACE_Time_Value * | timeout
| ) |

| Timed wait for handle to get exception ready.

ACE_INLINE int ACE::handle_read_ready | ( | ACE_HANDLE | handle,
|  | const ACE_Time_Value * | timeout
| ) |

| 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
| ) |

| 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
| ) |

| 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 | listener,
|  | const ACE_Time_Value * | timeout,
|  | int | is_tli = `0`
| ) |

| 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).

ACE_INLINE int ACE::handle_write_ready | ( | ACE_HANDLE | handle,
|  | const ACE_Time_Value * | timeout
| ) |

| Timed wait for handle to get write ready.

u_long ACE::hash_pjw | ( | const wchar_t * | str,
|  | size_t | len
| ) |

| Computes the hash value of {str} using the "Hash PJW" routine.

u_long ACE::hash_pjw | ( | const wchar_t * | str | ) |

| Computes the hash value of {str} using the "Hash PJW" routine.

u_long ACE::hash_pjw | ( | const char * | str,
|  | size_t | len
| ) |

| Computes the hash value of {str} using the "Hash PJW" routine.

u_long ACE::hash_pjw | ( | const char * | str | ) |

| Computes the hash value of {str} using the "Hash PJW" routine.

ACE_INLINE u_char ACE::hex2byte | ( | ACE_TCHAR | c | ) |

| 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
| ) |

| 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.

bool ACE::is_sock_error | ( | int | error | ) |

| Determins whether the given error code corresponds to to a WinSock error. If so returns true, false otherwise. For internal use only.

ACE_INLINE u_long ACE::log2 | ( | u_long | num | ) |

| Computes the base 2 logarithm of {num}.

u_int ACE::major_version | ( | void |  | ) |

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

int ACE::map_errno | ( | int | error | ) |

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

int ACE::max_handles | ( | void |  | ) |

| 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
| ) |

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

u_int ACE::minor_version | ( | void |  | ) |

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

ACE_INLINE ACE_TCHAR ACE::nibble2hex | ( | u_int | n | ) |

| Hex conversion utility.

int ACE::out_of_handles | ( | int | error | ) |

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

int ACE::process_active | ( | pid_t | pid | ) |

| 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.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE ssize_t ACE::read_n | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | size_t * | bytes_transferred = `0`
| ) |

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

void ACE::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.

ssize_t ACE::recv | ( | ACE_HANDLE | handle,
|  | size_t | n,
|  |  | ...
| ) |

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 | len,
|  | const ACE_Time_Value * | timeout = `0`
| ) |

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

ACE_INLINE ssize_t ACE::recv_i | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len
| ) |

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

ACE_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`
| ) |

ACE_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`
| ) |

ssize_t ACE::recv_n_i | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | const ACE_Time_Value * | timeout,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::recv_n_i | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::recv_n_i | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | int | flags,
|  | const ACE_Time_Value * | timeout,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::recv_n_i | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | int | flags,
|  | size_t * | bytes_transferred
| ) |

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

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

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

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

ssize_t ACE::recvv_n_i | ( | ACE_HANDLE | handle,
|  | iovec * | iov,
|  | int | iovcnt,
|  | const ACE_Time_Value * | timeout,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::recvv_n_i | ( | ACE_HANDLE | handle,
|  | iovec * | iov,
|  | int | iovcnt,
|  | size_t * | bytes_transferred
| ) |

void ACE::restore_non_blocking_mode | ( | ACE_HANDLE | handle,
|  | int | val
| ) |

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

size_t ACE::round_to_allocation_granularity | ( | off_t | len | ) |

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

size_t ACE::round_to_pagesize | ( | off_t | length | ) |

| 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`
| ) |

| Wrapper facade for the most common use of `select` that uses `ACE_Handle_Sets`.

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`
| ) |

| Wrapper facade for `select` that uses `ACE_Handle_Sets`.

ssize_t ACE::send | ( | ACE_HANDLE | handle,
|  | size_t | n,
|  |  | ...
| ) |

| Varargs variant.

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

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

ACE_INLINE ssize_t ACE::send_i | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | len
| ) |

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`
| ) |

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

ACE_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`
| ) |

ACE_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`
| ) |

ssize_t ACE::send_n_i | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | len,
|  | const ACE_Time_Value * | timeout,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::send_n_i | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | len,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::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 ACE::send_n_i | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | len,
|  | int | flags,
|  | size_t * | bytes_transferred
| ) |

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

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`
| ) |

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

ACE_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`
| ) |

ssize_t ACE::sendv_n_i | ( | ACE_HANDLE | handle,
|  | const iovec * | iov,
|  | int | iovcnt,
|  | const ACE_Time_Value * | timeout,
|  | size_t * | bytes_transferred
| ) |

ssize_t ACE::sendv_n_i | ( | ACE_HANDLE | handle,
|  | const iovec * | iov,
|  | int | iovcnt,
|  | size_t * | bytes_transferred
| ) |

int ACE::set_handle_limit | ( | int | new_limit = `-1`,
|  | int | increase_limit_only = `0`
| ) |

| Reset the limit on the number of open handles. If new_limit == -1 set the limit to the maximum allowable. Otherwise, set the limit value to new_limit. If increase_limit_only is non-0 then only allow increases to the limit.

const ACE_TCHAR * ACE::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. For internal use only.

ACE_INLINE void ACE::strdelete | ( | wchar_t * | s | ) |

ACE_INLINE void ACE::strdelete | ( | char * | s | ) |

| Delete the memory allocated by `strnew`.

const wchar_t * ACE::strend | ( | const wchar_t * | s | ) |

const char * ACE::strend | ( | const char * | s | ) |

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

ACE_TCHAR * ACE::strenvdup | ( | const ACE_TCHAR * | str | ) |

| 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
| ) |

char * ACE::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.

wchar_t * ACE::strnew | ( | const wchar_t * | s | ) |

char * ACE::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.

wchar_t * ACE::strnnew | ( | const wchar_t * | str,
|  | size_t | n
| ) |

char * ACE::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.

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

ACE_INLINE 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`
| ) |

ssize_t ACE::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 ACE::t_rcv_n_i | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | int * | flags,
|  | size_t * | bytes_transferred
| ) |

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

ACE_INLINE 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`
| ) |

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 * | bytes_transferred
| ) |

ssize_t ACE::t_snd_n_i | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | len,
|  | int | flags,
|  | size_t * | bytes_transferred
| ) |

int ACE::terminate_process | ( | pid_t | pid | ) |

| 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`
| ) |

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_TCHARs`. 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.

ACE_INLINE void ACE::unique_name | ( | const void * | object,
|  | ACE_TCHAR * | name,
|  | size_t | length
| ) |

| 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}.

bool ACE::wild_match | ( | const char * | s,
|  | const char * | pattern,
|  | bool | case_sensitive = `true`
| ) |

| Simple wildcard matching function supporting '*' and '?' return true if string s matches pattern.

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

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

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

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