Main Page   Namespace List   Class Hierarchy   Alphabetical List   Compound List   File List   Namespace Members   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:

Inheritance graph
[legend]
Collaboration diagram for ACE:

Collaboration graph
[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)
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)
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)
char * strnew (const char *s)
void strdelete (char *s)
 Delete the memory allocated by <strnew>.

char * strndup (const char *str, size_t n)
char * strnnew (const char *str, size_t n)
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.

size_t round_to_allocation_granularity (off_t len)
 Rounds the request to a multiple of the allocation granularity.

size_t format_hexdump (const char *buffer, size_t size, ACE_TCHAR *obuf, size_t obuf_sz)
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)
u_long crc32 (const char *buf, ACE_UINT32 len)
u_long crc32 (iovec *iov, int len)
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)
const ACE_TCHAR * sock_error (int error)
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 <ACE_Handle_Set>s.

int select (int width, ACE_Handle_Set &readfds, const ACE_Time_Value *timeout=0)
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)
int enter_send_timedwait (ACE_HANDLE handle, const ACE_Time_Value *timeout, int &val)
void record_and_set_non_blocking_mode (ACE_HANDLE handle, int &val)
void restore_non_blocking_mode (ACE_HANDLE handle, int val)
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.

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)
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)
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 (  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 *    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    d )  [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 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
)  [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    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 <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 *    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]
 

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
)  [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 *    bytes_transferred
)  [static, private]
 

ssize_t ACE::recv_n_i (  ACE_HANDLE    handle,
void *    buf,
size_t    len,
size_t *    bytes_transferred
)  [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 *    bytes_transferred
)  [static, private]
 

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

ssize_t ACE::recvv_n_i (  ACE_HANDLE    handle,
iovec *    iov,
int    iovcnt,
size_t *    bytes_transferred
)  [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 <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    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 *    bytes_transferred
)  [static, private]
 

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

ssize_t ACE::send_n_i (  ACE_HANDLE    handle,
const void *    buf,
size_t    len,
int    flags,
size_t *    bytes_transferred
)  [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 *    iov,
int    iovcnt,
const ACE_Time_Value *    timeout,
size_t *    bytes_transferred
)  [static, private]
 

ssize_t ACE::sendv_n_i (  ACE_HANDLE    handle,
const iovec *    iov,
int    iovcnt,
size_t *    bytes_transferred
)  [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]
 

ASYS_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
)  [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 *    bytes_transferred
)  [static, private]
 

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

ASYS_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
)  [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 *    bytes_transferred
)  [static, private]
 

ssize_t ACE::t_snd_n_i (  ACE_HANDLE    handle,
const void *    buf,
size_t    len,
int    flags,
size_t *    bytes_transferred
)  [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, 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 *    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 [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:
Generated on Fri Apr 2 16:46:09 2004 for ACE by doxygen1.2.18