ACE Namespace Reference

The namespace containing the ACE framework itself. More...


Classes

struct  ACE::If_Then_Else< true, Ta, Tb >
struct  ACE::If_Then_Else< false, Ta, Tb >
struct  VP_traits
 Value_Ptr traits template structure. More...
class  Value_Ptr
 Smart pointer implementation designed for use as a class member. More...

Functions

int out_of_handles (int error)
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.
bool debug (void)
void debug (bool onoff)
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.
int select (int width, ACE_Handle_Set &readfds, const ACE_Time_Value *timeout)
int terminate_process (pid_t pid)
int process_active (pid_t pid)
const ACE_TCHAR * execname (const ACE_TCHAR *old_name)
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 char *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 hash_pjw (const wchar_t *str)
 Computes the hash value of {str} using the "Hash PJW" routine.
ACE_TCHAR * strenvdup (const ACE_TCHAR *str)
const ACE_TCHAR * basename (const ACE_TCHAR *pathname, ACE_TCHAR delim)
const ACE_TCHAR * dirname (const ACE_TCHAR *pathname, ACE_TCHAR delim)
ssize_t recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, size_t *bt)
ssize_t recv_n_i (ACE_HANDLE handle, void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bt)
ssize_t t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, size_t *bt)
ssize_t t_rcv_n_i (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout, size_t *bt)
ssize_t recv_n_i (ACE_HANDLE handle, void *buf, size_t len, size_t *bt)
ssize_t recv_n_i (ACE_HANDLE handle, void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bt)
ssize_t recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bt)
ssize_t recvv_n_i (ACE_HANDLE handle, iovec *iov, int iovcnt, const ACE_Time_Value *timeout, size_t *bt)
ssize_t send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bt)
ssize_t send_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bt)
ssize_t t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, size_t *bt)
ssize_t t_snd_n_i (ACE_HANDLE handle, const void *buf, size_t len, int flags, const ACE_Time_Value *timeout, size_t *bt)
ssize_t send_n_i (ACE_HANDLE handle, const void *buf, size_t len, size_t *bt)
ssize_t send_n_i (ACE_HANDLE handle, const void *buf, size_t len, const ACE_Time_Value *timeout, size_t *bt)
ssize_t sendv_n_i (ACE_HANDLE handle, const iovec *i, int iovcnt, size_t *bt)
ssize_t sendv_n_i (ACE_HANDLE handle, const iovec *i, int iovcnt, const ACE_Time_Value *timeout, size_t *bt)
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)
size_t format_hexdump (const char *buffer, size_t size, ACE_TCHAR *obuf, size_t obuf_sz)
ACE_TCHAR * timestamp (ACE_TCHAR date_and_time[], int date_and_timelen, int return_pointer_to_first_digit)
size_t round_to_pagesize (size_t len)
 Rounds the request to a multiple of the page size.
size_t round_to_allocation_granularity (size_t len)
 Rounds the request to a multiple of the allocation granularity.
ACE_HANDLE handle_timed_complete (ACE_HANDLE h, const ACE_Time_Value *timeout, int is_tli)
int handle_timed_accept (ACE_HANDLE listener, ACE_Time_Value *timeout, int restart)
int daemonize (const ACE_TCHAR pathname[], bool close_all_handles, const ACE_TCHAR program_name[])
pid_t fork (const ACE_TCHAR *program_name, int avoid_zombies)
int max_handles (void)
int set_handle_limit (int new_limit, int increase_limit_only)
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)
const ACE_TCHAR * sock_error (int error)
bool is_sock_error (int error)
char * strndup (const char *str, size_t n)
wchar_t * strndup (const wchar_t *str, size_t n)
char * strnnew (const char *str, size_t n)
wchar_t * strnnew (const wchar_t *str, size_t n)
const char * strend (const char *s)
const wchar_t * strend (const wchar_t *s)
char * strnew (const char *s)
wchar_t * strnew (const wchar_t *s)
bool wild_match (const char *str, const char *pat, bool case_sensitive)
ACE_NAMESPACE_INLINE_FUNCTION void strdelete (char *s)
 Delete the memory allocated by strnew.
ACE_NAMESPACE_INLINE_FUNCTION void strdelete (wchar_t *s)
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 int map_errno (int error)
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_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_NAMESPACE_INLINE_FUNCTION
ssize_t 		recv_i (ACE_HANDLE handle, void *buf, size_t len)
ACE_NAMESPACE_INLINE_FUNCTION
ssize_t 		send_i (ACE_HANDLE handle, const void *buf, size_t len)
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
int 		set_flags (ACE_HANDLE handle, int flags)
 Set flags associated with handle.
int clr_flags (ACE_HANDLE handle, int flags)
 Clear flags associated with handle.
ACE_NAMESPACE_INLINE_FUNCTION int get_flags (ACE_HANDLE handle)
 Return the current setting of flags associated with handle.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
ACE_HANDLE 		handle_timed_open (ACE_Time_Value *timeout, const ACE_TCHAR *name, int flags, int perms, LPSECURITY_ATTRIBUTES sa)
int init (void)
int fini (void)
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
int 		ldfind (const ACE_TCHAR *filename, ACE_TCHAR pathname[], size_t maxpathnamelen)
FILE * ldopen (const ACE_TCHAR *filename, const ACE_TCHAR *type)
ACE_TCHAR * ldname (const ACE_TCHAR *entry_point)
int get_temp_dir (ACE_TCHAR *buffer, size_t buffer_len)
ACE_HANDLE open_temp_file (const ACE_TCHAR *name, int mode, int perm)
size_t strrepl (char *s, char search, char replace)
char * strsplit_r (char *str, const char *token, char *&next_start)
wchar_t * strsplit_r (wchar_t *s, const wchar_t *token, wchar_t *&next_start)
 As strsplit_r, but for wide characters.
size_t strrepl (wchar_t *s, wchar_t search, wchar_t replace)
 As strrepl, but for wide characters.
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
int 		bind_port (ACE_HANDLE handle, ACE_UINT32 ip_addr=INADDR_ANY, int address_family=AF_UNSPEC)
 Bind a new unused port to handle.
int get_bcast_addr (ACE_UINT32 &bcast_addr, const ACE_TCHAR *host_name, ACE_UINT32 host_addr, ACE_HANDLE handle)
int get_fqdn (ACE_INET_Addr const &addr, char hostname[], size_t len)
 Get fully qualified host/domain name.
int get_ip_interfaces (size_t &count, ACE_INET_Addr *&addrs)
int count_interfaces (ACE_HANDLE handle, size_t &how_many)
ACE_HANDLE get_handle (void)
bool ipv4_enabled (void)
int ipv6_enabled (void)
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)
ssize_t t_rcv (ACE_HANDLE handle, void *buf, size_t len, int *flags, const ACE_Time_Value *timeout)
ssize_t recv (ACE_HANDLE handle, void *buf, size_t n, const ACE_Time_Value *timeout)
ssize_t recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags, const ACE_Time_Value *timeout)
ssize_t recvfrom (ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen, const ACE_Time_Value *timeout)
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)
ssize_t recv_n (ACE_HANDLE handle, ACE_Message_Block *message_block, const ACE_Time_Value *timeout, size_t *bt)
ssize_t send (ACE_HANDLE handle, const void *buf, size_t n, int flags, const ACE_Time_Value *timeout)
ssize_t t_snd (ACE_HANDLE handle, const void *buf, size_t n, int flags, const ACE_Time_Value *timeout)
ssize_t send (ACE_HANDLE handle, const void *buf, size_t n, const ACE_Time_Value *timeout)
ssize_t sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags, const ACE_Time_Value *timeout)
ssize_t sendto (ACE_HANDLE handle, const char *buf, int len, int flags, const struct sockaddr *addr, int addrlen, const ACE_Time_Value *timeout)
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)
ssize_t write_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, size_t *bt)
ssize_t send_n (ACE_HANDLE handle, const ACE_Message_Block *message_block, const ACE_Time_Value *timeout, size_t *bt)
ssize_t readv_n (ACE_HANDLE handle, iovec *iov, int iovcnt, size_t *bt)
ssize_t writev_n (ACE_HANDLE handle, const iovec *i, int iovcnt, size_t *bt)
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_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_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_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_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)

Variables

size_t allocation_granularity_ = 0
size_t pagesize_ = 0
char debug_
unsigned int init_fini_count_ = 0

Detailed Description

The namespace containing the ACE framework itself.

The ACE namespace contains all types (classes, structures, typedefs, etc), and global functions and variables in the ACE framework.

Function Documentation

ACE_Export 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 '/'.

ACE_Export u_int ACE::beta_version ( void   ) 

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

ACE_Export int ACE::bind_port ( ACE_HANDLE  handle,
ACE_UINT32  ip_addr,
int  address_family 
)

Bind a new unused port to handle.

ACE_Export int ACE::clr_flags ( ACE_HANDLE  handle,
int  flags 
)

Clear flags associated with handle.

ACE_Export u_int ACE::compiler_beta_version ( void   ) 

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

ACE_Export u_int ACE::compiler_major_version ( void   ) 

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

ACE_Export u_int ACE::compiler_minor_version ( void   ) 

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

ACE_Export const ACE_TCHAR * ACE::compiler_name ( void   ) 

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

ACE_Export int ACE::count_interfaces ( ACE_HANDLE  handle,
size_t &  how_many 
)

Helper routine for get_ip_interfaces, differs by UNIX platform so put into own subroutine. perform some ioctls to retrieve ifconf list of ifreq structs.

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.

ACE_Export int ACE::daemonize ( const ACE_TCHAR  pathname[] = ACE_TEXT("/"),
bool  close_all_handles = ACE_DEFAULT_CLOSE_ALL_HANDLES,
const ACE_TCHAR  program_name[] = ACE_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.

ACE_Export void ACE::debug ( bool  onoff  ) 

ACE_Export bool ACE::debug ( void   ) 

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

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

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

ACE_Export 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 [].

ACE_Export int ACE::fini ( void   ) 

Shut down ACE library services. Can be called only once per program invocation.

Returns:
Returns 0 on success, -1 on failure, and 1 if it had already been called.

ACE_Export pid_t ACE::fork ( const ACE_TCHAR *  program_name = ACE_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).

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

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

Euclid's greatest common divisor algorithm.

ACE_Export int ACE::get_bcast_addr ( ACE_UINT32 &  bcast_addr,
const ACE_TCHAR *  hostname = 0,
ACE_UINT32  host_addr = 0,
ACE_HANDLE  handle = ACE_INVALID_HANDLE 
)

Get our broadcast address based on our host_addr. If hostname is non-0 we'll use it to determine our IP address. If handle is not ACE_INVALID_HANDLE then we'll use this to determine our broadcast address, otherwise we'll have to create a socket internally (and free it). Returns -1 on failure and 0 on success.

ACE_BEGIN_VERSIONED_NAMESPACE_DECL ACE_INLINE int ACE::get_flags ( ACE_HANDLE  handle  ) 

Return the current setting of flags associated with handle.

ACE_Export int ACE::get_fqdn ( ACE_INET_Addr const &  addr,
char  hostname[],
size_t  len 
)

Get fully qualified host/domain name.

ACE_Export ACE_HANDLE ACE::get_handle ( void   ) 

Routine to return a handle from which ioctl requests can be made. Caller must close the handle.

ACE_Export int ACE::get_ip_interfaces ( size_t &  count,
ACE_INET_Addr *&  addr_array 
)

Return count and array of all configured IP interfaces on this host, rc = 0 on success (count == number of interfaces else -1). Caller is responsible for calling delete [] on addr_array.

ACE_Export int ACE::get_temp_dir ( ACE_TCHAR *  buffer,
size_t  buffer_len 
)

Returns the temporary directory including the trailing slash in buffer. Returns -1 for an error or if the buffer_len is not long enough.

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.

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

ACE_Export 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_Export 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_Export ACE_HANDLE ACE::handle_timed_open ( ACE_Time_Value *  timeout,
const ACE_TCHAR *  name,
int  flags,
int  perms,
LPSECURITY_ATTRIBUTES  sa = 0 
)

Wait up to timeout amount of time to actively open a device. This method doesn't perform the connect, it just does the timed wait.

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

Timed wait for handle to get write ready.

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

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

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

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

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

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

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

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.

ACE_Export int ACE::init ( void   ) 

This class implements the functions for the initialization and shutting down ACE. These functions are called only once per ACE invokation.

Returns:
Returns 0 on success, -1 on failure, and 1 if it had already been called.

ACE_Export bool ACE::ipv4_enabled ( void   ) 

Returns true if IPv4 is enabled on the current host; false if not. This is an execution-time check. If ACE has not been compiled with ACE_HAS_IPV6, it always returns true. This function tries to create a PF_INET socket, returning true if it succeeds, and false if it fails. Caches the result so it only gets checked once.

ACE_Export int ACE::ipv6_enabled ( void   ) 

Returns 1 if IPv6 is enabled on the current host; 0 if not. This is an execution-time check. If ACE has not been compiled with ACE_HAS_IPV6, it always returns 0. If ACE_HAS_IPV6 is enabled, this function tries to create a PF_INET6 socket, returning 1 if it succeeds, and 0 if it fails. Caches the result so it only gets checked once.

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

ACE_Export 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_Export int ACE::ldfind ( const ACE_TCHAR *  filename,
ACE_TCHAR  pathname[],
size_t  maxpathnamelen 
)

Finds the file filename either using an absolute path or using a relative path in conjunction with ACE_LD_SEARCH_PATH (e.g., $LD_LIBRARY_PATH on UNIX or the directories scaned by Win32 API SearchPath on Win32). This function will add appropriate suffix (e.g., .dll on Win32 or .so on UNIX) according to the OS platform. In addition, this function will apply the appropriate prefix (e.g., "lib" on UNIX and "" on Win32) if the filename doesn't match directly.

ACE_Export ACE_TCHAR * ACE::ldname ( const ACE_TCHAR *  entry_point  ) 

Transforms entry_point into a form that can be located in a dynamic library using <dlsym>. For example, with Win32/Borland extern "C" functions which use the default calling convention have a '_' prepended. Always returns a buffer that has been dynamically allocated using <operator new>="">.

ACE_Export FILE * ACE::ldopen ( const ACE_TCHAR *  filename,
const ACE_TCHAR *  type 
)

Uses ldfind to locate and open the appropriate filename and returns a pointer to the file, else it returns a NULL pointer. type specifies how the file should be open.

ACE_INLINE u_long ACE::log2 ( u_long  num  ) 

Computes the base 2 logarithm of {num}.

ACE_Export u_int ACE::major_version ( void   ) 

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

ACE_INLINE int ACE::map_errno ( int  error  ) 

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

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

ACE_Export u_long ACE::minimum_frame_size ( u_long  period1,
u_long  period2 
)

Calculates the minimum enclosing frame size for the given values.

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

ACE_Export ACE_HANDLE ACE::open_temp_file ( const ACE_TCHAR *  name,
int  mode,
int  perm = 0 
)

Opening the temp file. File is automagically unlinked when it is closed. This is useful for have temp files.

ACE_Export int ACE::out_of_handles ( int  error  ) 

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

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

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

ACE_Export ssize_t ACE::readv_n ( ACE_HANDLE  handle,
iovec *  iov,
int  iovcnt,
size_t *  bt 
)

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

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

ACE_Export ssize_t ACE::recv ( ACE_HANDLE  handle,
void *  buf,
size_t  n,
const ACE_Time_Value *  timeout 
)

ACE_Export ssize_t ACE::recv ( ACE_HANDLE  handle,
void *  buf,
size_t  len,
int  flags,
const ACE_Time_Value *  timeout 
)

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

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

ACE_Export ssize_t ACE::recv_n ( ACE_HANDLE  handle,
ACE_Message_Block *  message_block,
const ACE_Time_Value *  timeout,
size_t *  bt 
)

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

ACE_Export ssize_t ACE::recv_n_i ( ACE_HANDLE  handle,
void *  buf,
size_t  len,
size_t *  bt 
)

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

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

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

ACE_Export ssize_t ACE::recvmsg ( ACE_HANDLE  handle,
struct msghdr *  msg,
int  flags,
const ACE_Time_Value *  timeout 
)

ACE_Export ssize_t ACE::recvv ( ACE_HANDLE  handle,
iovec *  iov,
int  iovcnt,
const ACE_Time_Value *  timeout 
)

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

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

ACE_Export ssize_t ACE::recvv_n_i ( ACE_HANDLE  handle,
iovec *  iov,
int  iovcnt,
size_t *  bt 
)

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

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

ACE_Export size_t ACE::round_to_allocation_granularity ( size_t  len  ) 

Rounds the request to a multiple of the allocation granularity.

ACE_Export size_t ACE::round_to_pagesize ( size_t  len  ) 

Rounds the request to a multiple of the page size.

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

ACE_Export int ACE::select ( int  width,
ACE_Handle_Set *  readfds,
ACE_Handle_Set *  writefds,
ACE_Handle_Set *  exceptfds,
const ACE_Time_Value *  timeout 
)

Wrapper facade for select that uses ACE_Handle_Sets.

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

Varargs variant.

ACE_Export ssize_t ACE::send ( ACE_HANDLE  handle,
const void *  buf,
size_t  n,
const ACE_Time_Value *  timeout 
)

ACE_Export ssize_t ACE::send ( ACE_HANDLE  handle,
const void *  buf,
size_t  n,
int  flags,
const ACE_Time_Value *  timeout 
)

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

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

ACE_Export 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_Export ssize_t ACE::send_n_i ( ACE_HANDLE  handle,
const void *  buf,
size_t  len,
const ACE_Time_Value *  timeout,
size_t *  bt 
)

ACE_Export ssize_t ACE::send_n_i ( ACE_HANDLE  handle,
const void *  buf,
size_t  len,
size_t *  bt 
)

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

ACE_Export ssize_t ACE::send_n_i ( ACE_HANDLE  handle,
const void *  buf,
size_t  len,
int  flags,
size_t *  bt 
)

ACE_Export ssize_t ACE::sendmsg ( ACE_HANDLE  handle,
const struct msghdr *  msg,
int  flags,
const ACE_Time_Value *  timeout 
)

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

ACE_Export ssize_t ACE::sendv ( ACE_HANDLE  handle,
const iovec *  iov,
int  iovcnt,
const ACE_Time_Value *  timeout 
)

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

ACE_Export ssize_t ACE::sendv_n_i ( ACE_HANDLE  handle,
const iovec *  i,
int  iovcnt,
const ACE_Time_Value *  timeout,
size_t *  bt 
)

ACE_Export ssize_t ACE::sendv_n_i ( ACE_HANDLE  handle,
const iovec *  i,
int  iovcnt,
size_t *  bt 
)

ACE_Export int ACE::set_flags ( ACE_HANDLE  handle,
int  flags 
)

Set flags associated with handle.

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

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

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

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

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

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

ACE_Export wchar_t * ACE::strndup ( const wchar_t *  str,
size_t  n 
)

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

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

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

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

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

ACE_Export size_t ACE::strrepl ( wchar_t *  s,
wchar_t  search,
wchar_t  replace 
)

As strrepl, but for wide characters.

ACE_Export size_t ACE::strrepl ( char *  s,
char  search,
char  replace 
)

Replace all instances of search in s with replace. Returns the number of replacements made.

ACE_Export wchar_t * ACE::strsplit_r ( wchar_t *  str,
const wchar_t *  token,
wchar_t *&  next_start 
)

As strsplit_r, but for wide characters.

ACE_Export char * ACE::strsplit_r ( char *  s,
const char *  token,
char *&  next_start 
)

Splits string <s> into pieces separated by the string <token>. <next_start> is an opaque cookie handed back by the call to store its state for the next invocation, thus making it re-entrant. This operates very similar to Perl's <split> function except that it returns pieces one at a time instead of into an array.

ACE_Export ssize_t ACE::t_rcv ( ACE_HANDLE  handle,
void *  buf,
size_t  len,
int *  flags,
const ACE_Time_Value *  timeout 
)

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

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

ACE_Export ssize_t ACE::t_rcv_n_i ( ACE_HANDLE  handle,
void *  buf,
size_t  len,
int *  flags,
size_t *  bt 
)

ACE_Export ssize_t ACE::t_snd ( ACE_HANDLE  handle,
const void *  buf,
size_t  n,
int  flags,
const ACE_Time_Value *  timeout 
)

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 
)

Receive len bytes into buf from <handle> (uses the <ACE_OS::read> call, which uses the <read> system call on UNIX and the <ReadFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been read will be returned to the caller through<bytes_transferred>.

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

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

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

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.

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

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

Send len bytes from buf to handle (uses the <ACE_OS::write> calls, which is uses the <write> system call on UNIX and the <WriteFile> call on Win32). If errors occur, -1 is returned. If EOF occurs, 0 is returned. Whatever data has been transmitted will be returned to the caller through <bytes_transferred>.

ACE_Export 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_Export ssize_t ACE::writev_n ( ACE_HANDLE  handle,
const iovec *  i,
int  iovcnt,
size_t *  bt 
)

Variable Documentation

size_t ACE::allocation_granularity_ = 0

char ACE::debug_

ACE_BEGIN_VERSIONED_NAMESPACE_DECL unsigned int ACE::init_fini_count_ = 0

Counter to match <init()>/<fini()> calls. <init()> must increment it; <fini()> must decrement it. <fini()> then does nothing until it reaches 0.

size_t ACE::pagesize_ = 0

Generated on Wed Apr 23 02:44:03 2008 for ACE by  doxygen 1.5.5