This namespace defines an OS independent programming API that shields developers from nonportable aspects of writing efficient system programs on Win32, POSIX and other versions of UNIX, and various real-time operating systems. More...

Classes
class	ace_flock_t
	OS file locking structure. More...

struct	macaddr_node_t

Typedefs
typedef ACE_WCHAR_T	WChar

Enumerations
enum	ACE_HRTimer_Op { ACE_HRTIMER_START = 0x0 , ACE_HRTIMER_INCR = 0x1 , ACE_HRTIMER_STOP = 0x2 , ACE_HRTIMER_GETTIME = 0xFFFF }

Functions
unsigned long	inet_addr (const char *name)

int	inet_aton (const char strptr, struct in_addr addr)

char *	inet_ntoa (const struct in_addr addr)

const char *	inet_ntop (int family, const void addrptr, char strptr, size_t len)

int	inet_pton (int family, const char strptr, void addrptr)

int	posix_devctl (int filedes, int dcmd, void dev_data_ptr, size_t nbyte, int dev_info_ptr)

void	closedir (ACE_DIR *)

ACE_DIR *	opendir (const ACE_TCHAR *filename)

struct ACE_DIRENT *	readdir (ACE_DIR *)

void	rewinddir (ACE_DIR *)

int	scandir (const ACE_TCHAR dirname, struct ACE_DIRENT *namelist[], ACE_SCANDIR_SELECTOR selector, ACE_SCANDIR_COMPARATOR comparator)

int	alphasort (const void , const void )

void	seekdir (ACE_DIR *, long loc)

long	telldir (ACE_DIR *)

int	scandir_emulation (const ACE_TCHAR dirname, ACE_DIRENT *namelist[], ACE_SCANDIR_SELECTOR selector, ACE_SCANDIR_COMPARATOR comparator)

int	dlclose (ACE_SHLIB_HANDLE handle)

ACE_TCHAR *	dlerror ()

ACE_SHLIB_HANDLE	dlopen (const ACE_TCHAR *filename, int mode=ACE_DEFAULT_SHLIB_MODE)

void *	dlsym (ACE_SHLIB_HANDLE handle, const ACE_TCHAR *symbol)

int	last_error ()

void	last_error (int error)

int	set_errno_to_last_error ()

int	set_errno_to_wsa_last_error ()

int	fcntl (ACE_HANDLE handle, int cmd, long arg=0)

ACE_HANDLE	open (const char *filename, int mode, mode_t perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)

ACE_HANDLE	open (const wchar_t *filename, int mode, mode_t perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)

template<typename T >
T	floor (T x)
	This method computes the largest integral value not greater than x.

template<typename T >
T	ceil (T x)
	This method computes the smallest integral value not less than x.

double	log2 (double x)
	This method computes the base-2 logarithm of x.

struct hostent *	gethostbyaddr (const char *addr, int length, int type)

struct hostent *	gethostbyaddr_r (const char addr, int length, int type, struct hostent result, ACE_HOSTENT_DATA buffer, int *h_errnop)

struct hostent *	gethostbyname (const char *name)

struct hostent *	gethostbyname_r (const char name, struct hostent result, ACE_HOSTENT_DATA buffer, int *h_errnop)

struct hostent *	getipnodebyaddr (const void *src, size_t len, int family)

struct hostent *	getipnodebyname (const char *name, int family, int flags=0)

int	getmacaddress (struct macaddr_node_t *node)

struct protoent *	getprotobyname (const char *name)

struct protoent *	getprotobyname_r (const char name, struct protoent result, ACE_PROTOENT_DATA buffer)

struct protoent *	getprotobynumber (int proto)

struct protoent *	getprotobynumber_r (int proto, struct protoent *result, ACE_PROTOENT_DATA buffer)

struct servent *	getservbyname (const char svc, const char proto)

struct servent *	getservbyname_r (const char svc, const char proto, struct servent *result, ACE_SERVENT_DATA buf)

int	getaddrinfo (const char name, const char service, const addrinfo hints, addrinfo *result)

void	freeaddrinfo (addrinfo *result)

const ACE_TCHAR *	gai_strerror (int errcode)

int	getnameinfo (const sockaddr addr, ACE_SOCKET_LEN addr_len, char host, ACE_SOCKET_LEN host_len, char *service, ACE_SOCKET_LEN service_len, unsigned int flags)

int	poll (struct pollfd pollfds, unsigned long len, const ACE_Time_Value tv=0)

int	poll (struct pollfd *pollfds, unsigned long len, const ACE_Time_Value &tv)

void	endpwent ()

struct passwd *	getpwent ()

struct passwd *	getpwnam (const char *user)

int	getpwnam_r (const char name, struct passwd pwd, char buffer, size_t bufsize, struct passwd *result)

void	setpwent ()

char *	compile (const char instring, char expbuf, char *endbuf)

int	step (const char str, char expbuf)

int	kill (pid_t pid, int signum)

int	pthread_sigmask (int how, const sigset_t nsp, sigset_t osp)

int	sigaction (int signum, const ACE_SIGACTION nsa, ACE_SIGACTION osa)

int	sigaddset (sigset_t *s, int signum)

int	sigdelset (sigset_t *s, int signum)

int	sigemptyset (sigset_t *s)

int	sigfillset (sigset_t *s)

int	sigismember (sigset_t *s, int signum)

ACE_SignalHandler	signal (int signum, ACE_SignalHandler)

int	sigprocmask (int how, const sigset_t nsp, sigset_t osp)

int	sigsuspend (const sigset_t *s)

int	raise (const int signum)

void	clearerr (FILE *fp)

char *	cuserid (char *user, size_t maxlen=ACE_MAX_USERID)

wchar_t *	cuserid (wchar_t *user, size_t maxlen=ACE_MAX_USERID)

int	asprintf (char *bufp, const char format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int	asprintf (wchar_t *bufp, const wchar_t format,...)

int	fclose (FILE *fp)

FILE *	fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)

int	fflush (FILE *fp)

int	fgetc (FILE *fp)

int	getc (FILE *fp)

int	fgetpos (FILE fp, fpos_t pos)

char *	fgets (char buf, int size, FILE fp)

wchar_t *	fgets (wchar_t buf, int size, FILE fp)

void	flock_adjust_params (ace_flock_t *lock, short whence, ACE_OFF_T &start, ACE_OFF_T &len)

int	flock_init (ace_flock_t lock, int flags=0, const ACE_TCHAR name=0, mode_t perms=0)

int	flock_destroy (ace_flock_t *lock, int unlink_file=1)

int	flock_rdlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)

int	flock_tryrdlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)

int	flock_trywrlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)

int	flock_unlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)

int	flock_wrlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)

ACE_HANDLE	fileno (FILE *stream)

FILE *	fopen (const char filename, const char mode)

FILE *	fopen (const char filename, const wchar_t mode)

FILE *	fopen (const wchar_t filename, const wchar_t mode)

FILE *	fopen (const wchar_t filename, const char mode)

LPSECURITY_ATTRIBUTES	default_win32_security_attributes (LPSECURITY_ATTRIBUTES)
	Default Win32 Security Attributes definition.

LPSECURITY_ATTRIBUTES	default_win32_security_attributes_r (LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, SECURITY_DESCRIPTOR *)

const ACE_TEXT_OSVERSIONINFO &	get_win32_versioninfo ()
	Return the win32 OSVERSIONINFO structure.

HINSTANCE	get_win32_resource_module ()

void	set_win32_resource_module (HINSTANCE)

int	fprintf (FILE fp, const char format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int	fprintf (FILE fp, const wchar_t format,...)

int	ungetc (int c, FILE *fp)

int	fputc (int c, FILE *fp)

int	putc (int c, FILE *fp)

int	fputs (const char s, FILE stream)

int	fputs (const wchar_t s, FILE stream)

size_t	fread (void ptr, size_t size, size_t nelems, FILE fp)

FILE *	freopen (const ACE_TCHAR filename, const ACE_TCHAR mode, FILE *stream)

int	fseek (FILE *fp, long offset, int ptrname)

int	fsetpos (FILE fp, fpos_t pos)

long	ftell (FILE *fp)

size_t	fwrite (const void ptr, size_t size, size_t nitems, FILE fp)

void	perror (const char *s)

void	perror (const wchar_t *s)

int	printf (const char *format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int	printf (const wchar_t *format,...)

int	puts (const char *s)

int	puts (const wchar_t *s)

int	rename (const char old_name, const char new_name, int flags=-1)

int	rename (const wchar_t old_name, const wchar_t new_name, int flags=-1)

void	rewind (FILE *fp)

int	snprintf (char buf, size_t maxlen, const char format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int	snprintf (wchar_t buf, size_t maxlen, const wchar_t format,...)

int	sprintf (char buf, const char format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int	sprintf (wchar_t buf, const wchar_t format,...)

char *	tempnam (const char dir=0, const char pfx=0)

wchar_t *	tempnam (const wchar_t dir, const wchar_t pfx=0)

int	vasprintf (char *bufp, const char format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int	vprintf (const char *format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int int	vfprintf (FILE fp, const char format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int int int	vsprintf (char buffer, const char format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int int int int	vsnprintf (char buffer, size_t maxlen, const char format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf

int int int int int int	vasprintf (wchar_t *bufp, const wchar_t format, va_list argptr)

int	vprintf (const wchar_t *format, va_list argptr)

int	vfprintf (FILE fp, const wchar_t format, va_list argptr)

int	vsprintf (wchar_t buffer, const wchar_t format, va_list argptr)

int	vsnprintf (wchar_t buffer, size_t maxlen, const wchar_t format, va_list argptr)

int	vasprintf_emulation (char *bufp, const char format, va_list argptr)

int	vaswprintf_emulation (wchar_t *bufp, const wchar_t format, va_list argptr)

int	strcasecmp (const char s, const char t)
	Compares two strings (case insensitive const char version).

int	strcasecmp (const wchar_t s, const wchar_t t)
	Compares two strings (case insensitive const wchar_t version).

int	strncasecmp (const char s, const char t, size_t len)
	Compares two arrays (case insensitive const char version).

int	strncasecmp (const wchar_t s, const wchar_t t, size_t len)
	Compares two arrays (case insensitive const wchar_t version).

int	getmsg (ACE_HANDLE handle, struct strbuf ctl, struct strbuf data, int *flags)

int	getpmsg (ACE_HANDLE handle, struct strbuf ctl, struct strbuf data, int band, int flags)

int	fattach (int handle, const char *path)

int	fdetach (const char *file)

int	ioctl (ACE_HANDLE handle, ACE_IOCTL_TYPE_ARG2 cmd, void *=0)
	UNIX-style `ioctl`.

int	ioctl (ACE_HANDLE socket, unsigned long io_control_code, void in_buffer_p, unsigned long in_buffer, void out_buffer_p, unsigned long out_buffer, unsigned long bytes_returned, ACE_OVERLAPPED overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
	QoS-enabled `ioctl`.

int	ioctl (ACE_HANDLE socket, unsigned long io_control_code, ACE_QoS &ace_qos, unsigned long bytes_returned, void buffer_p=0, unsigned long buffer=0, ACE_OVERLAPPED *overlapped=0, ACE_OVERLAPPED_COMPLETION_FUNC func=0)

int	isastream (ACE_HANDLE handle)

int	putmsg (ACE_HANDLE handle, const struct strbuf ctl, const struct strbuf data, int flags)

int	putpmsg (ACE_HANDLE handle, const struct strbuf ctl, const struct strbuf data, int band, int flags)

int	madvise (caddr_t addr, size_t len, int map_advice)

void *	mmap (void addr, size_t len, int prot, int flags, ACE_HANDLE handle, ACE_OFF_T off=0, ACE_HANDLE file_mapping=0, LPSECURITY_ATTRIBUTES sa=0, const ACE_TCHAR *file_mapping_name=0)

int	mprotect (void *addr, size_t len, int prot)

int	msync (void *addr, size_t len, int sync)

int	munmap (void *addr, size_t len)

ACE_HANDLE	shm_open (const ACE_TCHAR *filename, int mode, mode_t perms=0, LPSECURITY_ATTRIBUTES sa=0)

int	shm_unlink (const ACE_TCHAR *path)

int	msgctl (int msqid, int cmd, struct msqid_ds *)

int	msgget (key_t key, int msgflg)

ssize_t	msgrcv (int int_id, void *buf, size_t len, long type, int flags)

int	msgsnd (int int_id, const void *buf, size_t len, int flags)

int	getrlimit (int resource, struct rlimit *rl)

int	getrusage (int who, struct rusage *rusage)

int	setrlimit (int resource, const struct rlimit *rl)

int	select (int width, fd_set rfds, fd_set wfds=0, fd_set efds=0, const ACE_Time_Value tv=0)

int	select (int width, fd_set rfds, fd_set wfds, fd_set *efds, const ACE_Time_Value &tv)

ssize_t	sendfile (ACE_HANDLE out_fd, ACE_HANDLE in_fd, off_t *offset, size_t count)
	Wrapper for sendfile to transfer data between file descriptor.

void *	shmat (int int_id, const void *shmaddr, int shmflg)

int	shmctl (int int_id, int cmd, struct shmid_ds *buf)

int	shmdt (const void *shmaddr)

int	shmget (key_t key, size_t size, int flags)

ACE_HANDLE	accept (ACE_HANDLE handle, struct sockaddr addr, int addrlen)
	BSD-style `accept` (no QoS).

ACE_HANDLE	accept (ACE_HANDLE handle, struct sockaddr addr, int addrlen, const ACE_Accept_QoS_Params &qos_params)

int	bind (ACE_HANDLE s, struct sockaddr *name, int namelen)

int	closesocket (ACE_HANDLE s)
	Takes care of windows specific requirement to call closesocket.

int	connect (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
	BSD-style `connect` (no QoS).

int	connect (ACE_HANDLE handle, const sockaddr *addr, int addrlen, const ACE_QoS_Params &qos_params)

int	enum_protocols (int protocols, ACE_Protocol_Info protocol_buffer, u_long *buffer_length)

int	getpeername (ACE_HANDLE handle, struct sockaddr addr, int addrlen)

int	getsockname (ACE_HANDLE handle, struct sockaddr addr, int addrlen)

int	getsockopt (ACE_HANDLE handle, int level, int optname, char optval, int optlen)

ACE_HANDLE	join_leaf (ACE_HANDLE socket, const sockaddr *name, int namelen, const ACE_QoS_Params &qos_params)
	Joins a leaf node into a QoS-enabled multi-point session.

int	listen (ACE_HANDLE handle, int backlog)

ssize_t	recv (ACE_HANDLE handle, char *buf, size_t len, int flags=0)

ssize_t	recvfrom (ACE_HANDLE handle, char buf, size_t len, int flags, struct sockaddr addr, int *addrlen)

ssize_t	recvfrom (ACE_HANDLE handle, iovec buffers, int buffer_count, size_t &number_of_bytes_recvd, int &flags, struct sockaddr addr, int addrlen, ACE_OVERLAPPED overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)

ssize_t	recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)

ssize_t	recvv (ACE_HANDLE handle, iovec *iov, int iovlen)

ssize_t	send (ACE_HANDLE handle, const char *buf, size_t len, int flags=0)

ssize_t	send_partial_i (ACE_HANDLE handle, const char *buf, size_t len, int flags)

ssize_t	sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags)

ssize_t	sendto (ACE_HANDLE handle, const char buf, size_t len, int flags, const struct sockaddr addr, int addrlen)

ssize_t	sendto (ACE_HANDLE handle, const iovec buffers, int buffer_count, size_t &number_of_bytes_sent, int flags, const struct sockaddr addr, int addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)

ssize_t	sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt)

ssize_t	sendv_partial_i (ACE_HANDLE handle, const iovec *iov, int iovcnt)

int	setsockopt (ACE_HANDLE handle, int level, int optname, const char *optval, int optlen)
	Manipulate the options associated with a socket.

int	shutdown (ACE_HANDLE handle, int how)

unsigned int	if_nametoindex (const char *ifname)

char *	if_indextoname (unsigned int ifindex, char *ifname)

struct if_nameindex *	if_nameindex ()

void	if_freenameindex (struct if_nameindex *ptr)

int	socket_init (int version_high=1, int version_low=1)

int	socket_fini ()
	Finalize WinSock after last use (e.g., when a DLL is unloaded).

ACE_HANDLE	socket (int protocol_family, int type, int proto)
	Create a BSD-style socket (no QoS).

ACE_HANDLE	socket (int protocol_family, int type, int proto, ACE_Protocol_Info *protocolinfo, ACE_SOCK_GROUP g, u_long flags)

int	socketpair (int domain, int type, int protocol, ACE_HANDLE sv[2])

ACE_HANDLE	creat (const ACE_TCHAR *filename, mode_t mode)

ACE_OFF_T	filesize (ACE_HANDLE handle)

ACE_OFF_T	filesize (const ACE_TCHAR *handle)

int	fstat (ACE_HANDLE, ACE_stat *)

int	lstat (const char , ACE_stat )

int	lstat (const wchar_t , ACE_stat )

int	mkdir (const char *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)

int	mkdir (const wchar_t *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)

int	mkfifo (const ACE_TCHAR *file, mode_t mode=ACE_DEFAULT_FILE_PERMS)

int	stat (const char file, ACE_stat )

int	stat (const wchar_t file, ACE_stat )

mode_t	umask (mode_t cmask)

ACE_Time_Value	gettimeofday ()

ACE_Time_Value	gettimeofday_ ()

ssize_t	readv (ACE_HANDLE handle, const iovec *iov, int iovlen)

ssize_t	writev (ACE_HANDLE handle, const iovec *iov, int iovcnt)

int	uname (ACE_utsname *name)

pid_t	wait (int *=0)

pid_t	wait (pid_t pid, ACE_exitcode *status, int wait_options=0, ACE_HANDLE handle=0)

pid_t	waitpid (pid_t pid, ACE_exitcode *status=0, int wait_options=0, ACE_HANDLE handle=0)

void	cleanup_tss (const u_int main_thread)

int	condattr_init (ACE_condattr_t &attributes, int type=ACE_DEFAULT_SYNCH_TYPE)

int	condattr_synctype (ACE_condattr_t &attributes, int &type)

int	condattr_destroy (ACE_condattr_t &attributes)

int	condattr_setclock (ACE_condattr_t &attributes, clockid_t clock_id)

int	cond_broadcast (ACE_cond_t *cv)

int	cond_destroy (ACE_cond_t *cv)

int	cond_init (ACE_cond_t cv, short type=ACE_DEFAULT_SYNCH_TYPE, const char name=0, void *arg=0)

int	cond_init (ACE_cond_t cv, ACE_condattr_t &attributes, const char name=0, void *arg=0)

int	cond_init (ACE_cond_t cv, short type, const wchar_t name, void *arg=0)

int	cond_init (ACE_cond_t cv, ACE_condattr_t &attributes, const wchar_t name, void *arg=0)

int	cond_signal (ACE_cond_t *cv)

int	cond_timedwait (ACE_cond_t cv, ACE_mutex_t m, ACE_Time_Value *timeout)

int	cond_wait (ACE_cond_t cv, ACE_mutex_t m)

int	event_destroy (ACE_event_t *event)

int	event_init (ACE_event_t event, int manual_reset=0, int initial_state=0, int type=ACE_DEFAULT_SYNCH_TYPE, const char name=0, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)

int	event_init (ACE_event_t event, int type, ACE_condattr_t attributes, int manual_reset=0, int initial_state=0, const char name=0, void arg=0, LPSECURITY_ATTRIBUTES sa=0)

int	event_init (ACE_event_t event, int manual_reset, int initial_state, int type, const wchar_t name, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)

int	event_init (ACE_event_t event, int type, ACE_condattr_t attributes, int manual_reset, int initial_state, const wchar_t name, void arg=0, LPSECURITY_ATTRIBUTES sa=0)

int	event_pulse (ACE_event_t *event)

int	event_reset (ACE_event_t *event)

int	event_signal (ACE_event_t *event)

int	event_timedwait (ACE_event_t event, ACE_Time_Value timeout, int use_absolute_time=1)

int	event_wait (ACE_event_t *event)

int	lwp_getparams (ACE_Sched_Params &)

int	lwp_setparams (const ACE_Sched_Params &)

int	mutex_destroy (ACE_mutex_t *m)

int	mutex_init (ACE_mutex_t m, int lock_scope=ACE_DEFAULT_SYNCH_TYPE, const char name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0, int lock_type=0)

int	mutex_init (ACE_mutex_t m, int lock_scope, const wchar_t name, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0, int lock_type=0)

int	mutex_lock (ACE_mutex_t *m)

int	mutex_lock (ACE_mutex_t *m, int &abandoned)

int	mutex_lock (ACE_mutex_t *m, const ACE_Time_Value &timeout)

int	mutex_lock (ACE_mutex_t m, const ACE_Time_Value timeout)

void	mutex_lock_cleanup (void *mutex)
	Handle asynchronous thread cancellation cleanup.

int	mutex_trylock (ACE_mutex_t *m)

int	mutex_trylock (ACE_mutex_t *m, int &abandoned)

int	mutex_unlock (ACE_mutex_t *m)

long	priority_control (ACE_idtype_t, ACE_id_t, int, void *)
	Low-level interface to `priocntl(2)`.

int	recursive_mutex_cond_unlock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)

void	recursive_mutex_cond_relock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)

int	recursive_mutex_destroy (ACE_recursive_thread_mutex_t *m)

int	recursive_mutex_init (ACE_recursive_thread_mutex_t m, const ACE_TCHAR name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)

int	recursive_mutex_lock (ACE_recursive_thread_mutex_t *m)

int	recursive_mutex_lock (ACE_recursive_thread_mutex_t *m, const ACE_Time_Value &timeout)

int	recursive_mutex_lock (ACE_recursive_thread_mutex_t m, const ACE_Time_Value timeout)

int	recursive_mutex_trylock (ACE_recursive_thread_mutex_t *m)

int	recursive_mutex_unlock (ACE_recursive_thread_mutex_t *m)

int	rw_rdlock (ACE_rwlock_t *rw)

int	rw_tryrdlock (ACE_rwlock_t *rw)

int	rw_trywrlock (ACE_rwlock_t *rw)

int	rw_trywrlock_upgrade (ACE_rwlock_t *rw)

int	rw_unlock (ACE_rwlock_t *rw)

int	rw_wrlock (ACE_rwlock_t *rw)

int	rwlock_destroy (ACE_rwlock_t *rw)

int	rwlock_init (ACE_rwlock_t rw, int type=ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR name=0, void *arg=0)

int	sched_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)

int	scheduling_class (const char *class_name, ACE_id_t &)
	Find the scheduling class ID that corresponds to the class name.

int	sema_destroy (ACE_sema_t *s)

int	sema_init (ACE_sema_t s, u_int count, int type=ACE_DEFAULT_SYNCH_TYPE, const char name=0, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)

int	sema_init (ACE_sema_t s, u_int count, int type, ACE_condattr_t attributes, const char name=0, void arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)

int	sema_init (ACE_sema_t s, u_int count, int type, const wchar_t name, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)

int	sema_init (ACE_sema_t s, u_int count, int type, ACE_condattr_t attributes, const wchar_t name, void arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)

void	sema_avoid_unlink (ACE_sema_t *s, bool avoid_unlink)

int	sema_unlink (const char *name)

int	sema_post (ACE_sema_t *s)

int	sema_post (ACE_sema_t *s, u_int release_count)

int	sema_trywait (ACE_sema_t *s)

int	sema_wait (ACE_sema_t *s)

int	sema_wait (ACE_sema_t *s, ACE_Time_Value &tv)

int	sema_wait (ACE_sema_t s, ACE_Time_Value tv)

int	semctl (int int_id, int semnum, int cmd, semun)

int	semget (key_t key, int nsems, int flags)

int	semop (int int_id, struct sembuf *sops, size_t nsops)

int	set_scheduling_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
	Friendly interface to `priocntl(2)`.

int	sigtimedwait (const sigset_t set, siginfo_t info, const ACE_Time_Value *timeout)

int	sigwait (sigset_t set, int sig=0)

int	sigwaitinfo (const sigset_t set, siginfo_t info)

int	thr_cancel (ACE_thread_t t_id)

int	thr_cmp (ACE_hthread_t t1, ACE_hthread_t t2)

int	thr_continue (ACE_hthread_t target_thread)

int	thr_create (ACE_THR_FUNC func, void args, long flags, ACE_thread_t thr_id, ACE_hthread_t t_handle=0, long priority=ACE_DEFAULT_THREAD_PRIORITY, void stack=0, size_t stacksize=ACE_DEFAULT_THREAD_STACKSIZE, ACE_Base_Thread_Adapter thread_adapter=0, const char *thr_name=0)

int	thr_equal (ACE_thread_t t1, ACE_thread_t t2)

void	thr_exit (ACE_THR_FUNC_RETURN status=0)

int	thr_getconcurrency ()

int	thr_getprio (ACE_hthread_t id, int &priority)

int	thr_getprio (ACE_hthread_t id, int &priority, int &policy)

int	thr_getspecific (ACE_thread_key_t key, void **data)

int	thr_join (ACE_hthread_t waiter_id, ACE_THR_FUNC_RETURN *status)

int	thr_join (ACE_thread_t waiter_id, ACE_thread_t thr_id, ACE_THR_FUNC_RETURN status)

int	thr_get_affinity (ACE_hthread_t thr_id, size_t cpu_set_size, cpu_set_t *cpu_mask)

int	thr_set_affinity (ACE_hthread_t thr_id, size_t cpu_set_size, const cpu_set_t *cpu_mask)

int	thr_key_detach (ACE_thread_key_t key)

int	thr_key_used (ACE_thread_key_t key)

int	thr_keycreate (ACE_thread_key_t *key, ACE_THR_DEST)

int	thr_keyfree (ACE_thread_key_t key)

int	thr_kill (ACE_thread_t thr_id, int signum)

size_t	thr_min_stack ()

ACE_thread_t	thr_self ()

void	thr_self (ACE_hthread_t &)

const char *	thr_name ()

ssize_t	thr_id (char buffer[], size_t buffer_length)

pid_t	thr_gettid ()

ssize_t	thr_gettid (char buffer[], size_t buffer_length)

int	thr_setcancelstate (int new_state, int *old_state)
	State is THR_CANCEL_ENABLE or THR_CANCEL_DISABLE.

int	thr_setcanceltype (int new_type, int *old_type)
	Type is THR_CANCEL_DEFERRED or THR_CANCEL_ASYNCHRONOUS.

int	thr_setconcurrency (int hint)

int	thr_setprio (ACE_hthread_t ht_id, int priority, int policy=-1)

int	thr_setprio (const ACE_Sched_Priority prio)

int	thr_setspecific (ACE_thread_key_t key, void *data)

int	thr_sigsetmask (int how, const sigset_t nsm, sigset_t osm)

int	thr_suspend (ACE_hthread_t target_thread)

void	thr_testcancel ()

void	thr_yield ()

int	thread_mutex_destroy (ACE_thread_mutex_t *m)

int	thread_mutex_init (ACE_thread_mutex_t m, int lock_type=0, const char name=0, ACE_mutexattr_t *arg=0)

int	thread_mutex_init (ACE_thread_mutex_t m, int lock_type, const wchar_t name, ACE_mutexattr_t *arg=0)

int	thread_mutex_lock (ACE_thread_mutex_t *m)

int	thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value &timeout)

int	thread_mutex_lock (ACE_thread_mutex_t m, const ACE_Time_Value timeout)

int	thread_mutex_trylock (ACE_thread_mutex_t *m)

int	thread_mutex_unlock (ACE_thread_mutex_t *m)

void	unique_name (const void object, char name, size_t length)

char *	asctime (const struct tm *tm)

char *	asctime_r (const struct tm tm, char buf, int buflen)

int	clock_gettime (clockid_t, struct timespec *)

int	clock_settime (clockid_t, const struct timespec *)

ACE_TCHAR *	ctime (const time_t *t)

ACE_TCHAR *	ctime_r (const time_t clock, ACE_TCHAR buf, int buflen)

double	difftime (time_t t1, time_t t0)

ACE_hrtime_t	gethrtime (const ACE_HRTimer_Op=ACE_HRTIMER_GETTIME)

struct tm *	gmtime (const time_t *clock)

struct tm *	gmtime_r (const time_t clock, struct tm res)

struct tm *	localtime (const time_t *clock)

struct tm *	localtime_r (const time_t clock, struct tm res)

time_t	mktime (struct tm *timeptr)

int	nanosleep (const struct timespec requested, struct timespec remaining=0)

size_t	strftime (char s, size_t maxsize, const char format, const struct tm *timeptr) ACE_GCC_FORMAT_ATTRIBUTE(strftime

size_t char *	strptime (const char buf, const char format, struct tm *tm)

time_t	time (time_t *tloc=0)

long	timezone ()

void	tzset ()

int	access (const char *path, int amode)

int	access (const wchar_t *path, int amode)

unsigned int	alarm (u_int secs)

long	allocation_granularity ()

int	argv_to_string (int argc, ACE_TCHAR *argv, ACE_TCHAR &buf, bool substitute_env_args=true, bool quote_args=false)
	used by ARGV::argv_to_string() and ACE_OS::fork_exec()

int	argv_to_string (ACE_TCHAR *argv, ACE_TCHAR &buf, bool substitute_env_args=true, bool quote_args=false)

int	chdir (const char *path)

int	chdir (const wchar_t *path)

int	rmdir (const char *path)

int	rmdir (const wchar_t *path)

int	close (ACE_HANDLE handle)

ACE_HANDLE	dup (ACE_HANDLE handle)

ACE_HANDLE	dup (ACE_HANDLE handle, pid_t pid)

int	dup2 (ACE_HANDLE oldfd, ACE_HANDLE newfd)

int	execl (const char path, const char arg0,...)

int	execle (const char path, const char arg0,...)

int	execlp (const char file, const char arg0,...)

int	execv (const char path, char const argv[])

int	execve (const char path, char const argv[], char *const envp[])

int	execvp (const char file, char const argv[])

pid_t	fork ()

pid_t	fork (const ACE_TCHAR *program_name)

pid_t	fork_exec (ACE_TCHAR *argv[])

int	fsync (ACE_HANDLE handle)

int	ftruncate (ACE_HANDLE handle, ACE_OFF_T offset)

char *	getcwd (char *, size_t)

wchar_t *	getcwd (wchar_t *, size_t)

gid_t	getgid ()

gid_t	getegid ()

int	getopt (int argc, char const argv, const char *optstring)

long	getpagesize ()

pid_t	getpgid (pid_t pid)

pid_t	getpid ()

pid_t	getppid ()

uid_t	getuid ()

uid_t	geteuid ()

int	hostname (char name[], size_t maxnamelen)

int	hostname (wchar_t name[], size_t maxnamelen)

int	isatty (int handle)

int	isatty (ACE_HANDLE handle)

ACE_OFF_T	lseek (ACE_HANDLE handle, ACE_OFF_T offset, int whence)

long	num_processors ()
	Get the number of CPUs configured in the machine.

long	num_processors_online ()
	Get the number of CPUs currently online.

int	pipe (ACE_HANDLE handles[])

ssize_t	pread (ACE_HANDLE handle, void *buf, size_t nbyte, ACE_OFF_T offset)

ssize_t	pwrite (ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_OFF_T offset)

ssize_t	read (ACE_HANDLE handle, void *buf, size_t len)

ssize_t	read (ACE_HANDLE handle, void buf, size_t len, ACE_OVERLAPPED )

ssize_t	read_n (ACE_HANDLE handle, void buf, size_t len, size_t bytes_transferred=0)

ssize_t	readlink (const char path, char buf, size_t bufsiz)

void *	sbrk (intptr_t brk)

int	setgid (gid_t)

int	setegid (gid_t)

int	setpgid (pid_t pid, pid_t pgid)

int	setregid (gid_t rgid, gid_t egid)

int	setreuid (uid_t ruid, uid_t euid)

pid_t	setsid ()

int	setuid (uid_t)

int	seteuid (uid_t)

int	sleep (u_int seconds)

int	sleep (const ACE_Time_Value &tv)

int	string_to_argv (ACE_TCHAR buf, int &argc, ACE_TCHAR *&argv, bool substitute_env_args=true)

void	swab (const void src, void dest, ssize_t n)

long	sysconf (int)

long	sysinfo (int cmd, char *buf, long count)

int	truncate (const ACE_TCHAR *filename, ACE_OFF_T length)

useconds_t	ualarm (useconds_t usecs, useconds_t interval=0)

useconds_t	ualarm (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)

int	unlink (const char *path)

int	unlink (const wchar_t *path)

ssize_t	write (ACE_HANDLE handle, const void *buf, size_t nbyte)

ssize_t	write (ACE_HANDLE handle, const void buf, size_t nbyte, ACE_OVERLAPPED )

ssize_t	write_n (ACE_HANDLE handle, const void buf, size_t len, size_t bytes_transferred=0)

wint_t	fgetwc (FILE *fp)

u_int	wslen (const WChar *)

WChar *	wscpy (WChar , const WChar )

int	wscmp (const WChar , const WChar )

int	wsncmp (const WChar , const WChar , size_t len)

wint_t	ungetwc (wint_t c, FILE *fp)

int	t_accept (ACE_HANDLE fildes, ACE_HANDLE resfd, struct t_call *call)

char *	t_alloc (ACE_HANDLE fildes, int struct_type, int fields)

int	t_bind (ACE_HANDLE fildes, ACE_TBIND req, ACE_TBIND ret)

int	t_close (ACE_HANDLE fildes)

int	t_connect (ACE_HANDLE fildes, struct t_call sndcall, struct t_call rcvcall)

void	t_error (const char *errmsg)

int	t_free (char *ptr, int struct_type)

int	t_getinfo (ACE_HANDLE fildes, struct t_info *info)

int	t_getname (ACE_HANDLE fildes, struct netbuf *namep, int type)

int	t_getstate (ACE_HANDLE fildes)

int	t_listen (ACE_HANDLE fildes, struct t_call *call)

int	t_look (ACE_HANDLE fildes)

ACE_HANDLE	t_open (char path, int oflag, struct t_info info)

int	t_optmgmt (ACE_HANDLE handle, ACE_TOPTMGMT req, ACE_TOPTMGMT ret)

int	t_rcv (ACE_HANDLE fildes, char buf, unsigned int nbytes, int flags)

int	t_rcvdis (ACE_HANDLE fildes, struct t_discon *discon)

int	t_rcvrel (ACE_HANDLE fildes)

int	t_rcvudata (ACE_HANDLE fildes, struct t_unitdata unitdata, int flags)

int	t_rcvuderr (ACE_HANDLE fildes, struct t_uderr *uderr)

int	t_snd (ACE_HANDLE fildes, const char *buf, unsigned int nbytes, int flags)

int	t_snddis (ACE_HANDLE fildes, struct t_call *call)

int	t_sndrel (ACE_HANDLE fildes)

int	t_sync (ACE_HANDLE fildes)

int	t_unbind (ACE_HANDLE fildes)

Functions from <cctype>
Included are the functions defined in <cctype> and their <cwctype> equivalents. Since they are often implemented as macros, we don't use the same name here. Instead, we change by prepending "ace_".
int	ace_isalnum (ACE_TCHAR c)
	Returns true if the character is an alphanumeric character.

int	ace_isalpha (ACE_TCHAR c)
	Returns true if the character is an alphabetic character.

int	ace_isblank (ACE_TCHAR c)
	Returns true if the character is a control character.

int	ace_isascii (ACE_TCHAR c)
	Returns true if the character is a control character.

int	ace_iscntrl (ACE_TCHAR c)
	Returns true if the character is a control character.

int	ace_isdigit (ACE_TCHAR c)
	Returns true if the character is a decimal-digit character.

int	ace_isgraph (ACE_TCHAR c)
	Returns true if the character is a printable character other than a space.

int	ace_islower (ACE_TCHAR c)
	Returns true if the character is a lowercase character.

int	ace_isprint (ACE_TCHAR c)
	Returns true if the character is a printable character.

int	ace_ispunct (ACE_TCHAR c)
	Returns true if the character is a punctuation character.

int	ace_isspace (ACE_TCHAR c)
	Returns true if the character is a space character.

int	ace_isupper (ACE_TCHAR c)
	Returns true if the character is an uppercase character.

int	ace_isxdigit (ACE_TCHAR c)
	Returns true if the character is a hexadecimal-digit character.

int	ace_tolower (int c)
	Converts a character to lower case (char version).

wint_t	ace_towlower (wint_t c)
	Converts a character to lower case (wchar_t version).

int	ace_toupper (int c)
	Converts a character to upper case (char version).

wint_t	ace_towupper (wint_t c)
	Converts a character to upper case (wchar_t version).

int	ace_isctype (int c, ctype_t desc)
	Tests c for the property specified by the desc argument.

int	ace_iswctype (wint_t c, wctype_t desc)
	Tests c for the property specified by the desc argument.

Functions from <cstring>
Included are the functions defined in <cstring> and their <cwchar> equivalents. Todo To be complete, we should add strcoll, and strxfrm.
const void *	memchr (const void *s, int c, size_t len)
	Finds characters in a buffer (const void version).

void *	memchr (void *s, int c, size_t len)
	Finds characters in a buffer (void version).

int	memcmp (const void t, const void s, size_t len)
	Compares two buffers.

void *	memcpy (void t, const void s, size_t len)
	Copies one buffer to another.

void *	memmove (void t, const void s, size_t len)
	Moves one buffer to another.

void *	memset (void *s, int c, size_t len)
	Fills a buffer with a character value.

char *	strcat (char s, const char t)
	Appends a string to another string (char version).

wchar_t *	strcat (wchar_t s, const wchar_t t)
	Appends a string to another string (wchar_t version).

const char *	strchr (const char *s, int c)

const wchar_t *	strchr (const wchar_t *s, wchar_t c)

char *	strchr (char *s, int c)
	Finds the first occurrence of a character in a string (char version).

wchar_t *	strchr (wchar_t *s, wchar_t c)
	Finds the first occurrence of a character in a string (wchar_t version).

int	strcmp (const char s, const char t)
	Compares two strings (char version).

int	strcmp (const ACE_WCHAR_T s, const ACE_WCHAR_T t)
	Compares two strings (wchar_t version).

char *	strcpy (char s, const char t)
	Copies a string (char version).

wchar_t *	strcpy (wchar_t s, const wchar_t t)
	Copies a string (wchar_t version).

size_t	strcspn (const char s, const char reject)

size_t	strcspn (const wchar_t s, const wchar_t reject)

char *	strdup (const char *s)
	Returns a malloced duplicated string (char version).

wchar_t *	strdup (const wchar_t *s)
	Returns a malloced duplicated string (wchar_t version).

char *	strecpy (char des, const char src)

wchar_t *	strecpy (wchar_t s, const wchar_t t)

char *	strerror (int errnum)

char *	strsignal (int signum)

char *	strerror_r (int errnum, char *buf, size_t buflen)
	Finds characters in a buffer (const void version).

size_t	strlen (const char *s)
	Finds the length of a string (char version).

size_t	strlen (const ACE_WCHAR_T *s)
	Finds the length of a string (ACE_WCHAR_T version).

char *	strncat (char s, const char t, size_t len)
	Appends part of a string to another string (char version).

ACE_WCHAR_T *	strncat (ACE_WCHAR_T s, const ACE_WCHAR_T t, size_t len)
	Appends part of a string to another string (wchar_t version).

const char *	strnchr (const char *s, int c, size_t len)

const ACE_WCHAR_T *	strnchr (const ACE_WCHAR_T *s, ACE_WCHAR_T c, size_t len)

char *	strnchr (char *s, int c, size_t len)
	Finds the first occurrence of a character in an array (char version).

ACE_WCHAR_T *	strnchr (ACE_WCHAR_T *s, ACE_WCHAR_T c, size_t len)
	Finds the first occurrence of a character in an array (ACE_WCHAR_T version).

int	strncmp (const char s, const char t, size_t len)
	Compares two arrays (char version).

int	strncmp (const ACE_WCHAR_T s, const ACE_WCHAR_T t, size_t len)
	Compares two arrays (wchar_t version).

char *	strncpy (char s, const char t, size_t len)
	Copies an array (char version)

ACE_WCHAR_T *	strncpy (ACE_WCHAR_T s, const ACE_WCHAR_T t, size_t len)
	Copies an array (ACE_WCHAR_T version)

size_t	strnlen (const char *s, size_t maxlen)
	Finds the length of a limited-length string (char version).

size_t	strnlen (const ACE_WCHAR_T *s, size_t maxlen)
	Finds the length of a limited-length string (ACE_WCHAR_T version).

const char *	strnstr (const char s, const char t, size_t len)

const ACE_WCHAR_T *	strnstr (const ACE_WCHAR_T s, const ACE_WCHAR_T t, size_t len)

char *	strnstr (char s, const char t, size_t len)
	Finds the first occurrence of a substring in an array (char version).

ACE_WCHAR_T *	strnstr (ACE_WCHAR_T s, const ACE_WCHAR_T t, size_t len)
	Finds the first occurrence of a substring in an array (wchar_t version).

const char *	strpbrk (const char s1, const char s2)
	Searches for characters in a string (const char version).

const wchar_t *	strpbrk (const wchar_t s1, const wchar_t s2)
	Searches for characters in a string (const wchar_t version).

char *	strpbrk (char s1, const char s2)
	Searches for characters in a string (char version).

wchar_t *	strpbrk (wchar_t s1, const wchar_t s2)
	Searches for characters in a string (wchar_t version).

const char *	strrchr (const char *s, int c)

const wchar_t *	strrchr (const wchar_t *s, wchar_t c)

char *	strrchr (char *s, int c)
	Finds the last occurrence of a character in a string (char version).

wchar_t *	strrchr (wchar_t *s, wchar_t c)
	Finds the last occurrence of a character in a string (wchar_t version).

char *	strsncpy (char dst, const char src, size_t maxlen)
	This is a "safe" c string copy function (char version).

ACE_WCHAR_T *	strsncpy (ACE_WCHAR_T dst, const ACE_WCHAR_T src, size_t maxlen)
	This is a "safe" c string copy function (wchar_t version).

size_t	strspn (const char s1, const char s2)

size_t	strspn (const wchar_t s1, const wchar_t s2)

const char *	strstr (const char s, const char t)

const wchar_t *	strstr (const wchar_t s, const wchar_t t)

char *	strstr (char s, const char t)
	Finds the first occurrence of a substring in a string (char version).

wchar_t *	strstr (wchar_t s, const wchar_t t)
	Finds the first occurrence of a substring in a string (wchar_t version).

char *	strtok (char s, const char tokens)
	Finds the next token in a string (char version).

wchar_t *	strtok (wchar_t s, const wchar_t tokens)
	Finds the next token in a string (wchar_t version).

char *	strtok_r (char s, const char tokens, char **lasts)
	Finds the next token in a string (safe char version).

wchar_t *	strtok_r (ACE_WCHAR_T s, const ACE_WCHAR_T tokens, ACE_WCHAR_T **lasts)
	Finds the next token in a string (wchar_t version).

Variables
ACE_TEXT_OSVERSIONINFO	win32_versioninfo_

HINSTANCE	win32_resource_module_

int	socket_initialized_
	Keeps track of whether we've already initialized WinSock...

ACE_thread_t	NULL_thread

ACE_hthread_t	NULL_hthread

ACE_thread_key_t	NULL_key

Non-standard functions
These functions aren't in the standard.
ACE_EXIT_HOOK	exit_hook_ = 0
	Function that is called by <ACE_OS::exit>, if non-null.

void	_exit (int status=0)
	Function that is called by <ACE_OS::exit>, if non-null.

void	abort ()
	Function that is called by <ACE_OS::exit>, if non-null.

int	atexit (ACE_EXIT_HOOK func, const char *name=0)

int	atoi (const char *s)
	Function that is called by <ACE_OS::exit>, if non-null.

int	atoi (const wchar_t *s)
	Function that is called by <ACE_OS::exit>, if non-null.

long	atol (const char *s)
	Function that is called by <ACE_OS::exit>, if non-null.

long	atol (const wchar_t *s)
	Function that is called by <ACE_OS::exit>, if non-null.

double	atof (const char *s)
	Function that is called by <ACE_OS::exit>, if non-null.

double	atof (const wchar_t *s)
	Function that is called by <ACE_OS::exit>, if non-null.

void *	atop (const char *s)
	Function that is called by <ACE_OS::exit>, if non-null.

void *	atop (const wchar_t *s)
	Function that is called by <ACE_OS::exit>, if non-null.

void *	bsearch (const void key, const void base, size_t nel, size_t size, ACE_COMPARE_FUNC)
	Function that is called by <ACE_OS::exit>, if non-null.

void *	calloc (size_t elements, size_t sizeof_elements)
	Function that is called by <ACE_OS::exit>, if non-null.

void	exit (int status=0)
	Function that is called by <ACE_OS::exit>, if non-null.

void	free (void *)
	Function that is called by <ACE_OS::exit>, if non-null.

char *	getenv (const char *symbol)
	Function that is called by <ACE_OS::exit>, if non-null.

wchar_t *	getenv (const wchar_t *symbol)
	Function that is called by <ACE_OS::exit>, if non-null.

ACE_TCHAR *	getenvstrings ()
	Function that is called by <ACE_OS::exit>, if non-null.

char *	itoa (int value, char *string, int radix)
	Converts an integer to a string.

wchar_t *	itoa (int value, wchar_t *string, int radix)
	Converts an integer to a string.

char *	itoa_emulation (int value, char *string, int radix)
	Emulated itoa - Converts an integer to a string.

void *	malloc (size_t)
	Function that is called by <ACE_OS::exit>, if non-null.

ACE_HANDLE	mkstemp (char *s)
	Function that is called by <ACE_OS::exit>, if non-null.

ACE_HANDLE	mkstemp (wchar_t *s)
	Function that is called by <ACE_OS::exit>, if non-null.

char *	mktemp (char *s)
	Function that is called by <ACE_OS::exit>, if non-null.

wchar_t *	mktemp (wchar_t *s)
	Function that is called by <ACE_OS::exit>, if non-null.

int	putenv (const char *string)
	Function that is called by <ACE_OS::exit>, if non-null.

int	putenv (const wchar_t *string)
	Function that is called by <ACE_OS::exit>, if non-null.

void	qsort (void *base, size_t nel, size_t width, ACE_COMPARE_FUNC)
	Function that is called by <ACE_OS::exit>, if non-null.

int	setenv (const char envname, const char envval, int overwrite)
	Function that is called by <ACE_OS::exit>, if non-null.

int	unsetenv (const char *name)
	Function that is called by <ACE_OS::exit>, if non-null.

int	rand ()
	Function that is called by <ACE_OS::exit>, if non-null.

int	rand_r (unsigned int *seed)
	Function that is called by <ACE_OS::exit>, if non-null.

void *	realloc (void *, size_t)
	Function that is called by <ACE_OS::exit>, if non-null.

char *	realpath (const char file_name, char resolved_name)
	Function that is called by <ACE_OS::exit>, if non-null.

wchar_t *	realpath (const wchar_t file_name, wchar_t resolved_name)
	Function that is called by <ACE_OS::exit>, if non-null.

ACE_EXIT_HOOK	set_exit_hook (ACE_EXIT_HOOK hook)
	For use by ACE_Object_Manager only, to register its exit hook..

void	srand (u_int seed)
	Function that is called by <ACE_OS::exit>, if non-null.

ACE_TCHAR *	strenvdup (const ACE_TCHAR *str)
	Function that is called by <ACE_OS::exit>, if non-null.

double	strtod (const char s, char *endptr)
	Converts a string to a double value (char version).

double	strtod (const wchar_t s, wchar_t *endptr)
	Converts a string to a double value (wchar_t version).

long	strtol (const char s, char *ptr, int base)
	Converts a string to a long value (char version).

long	strtol (const wchar_t s, wchar_t *ptr, int base)
	Converts a string to a long value (wchar_t version).

unsigned long	strtoul (const char s, char *ptr, int base)
	Converts a string to an unsigned long value (char version).

unsigned long	strtoul (const wchar_t s, wchar_t *ptr, int base)
	Converts a string to an unsigned long value (wchar_t version).

ACE_INT64	strtoll (const char s, char *ptr, int base)
	Converts a string to a signed 64 bit int value (char version).

ACE_INT64	strtoll (const wchar_t s, wchar_t *ptr, int base)
	Converts a string to a signed 64 bit int value (wchar_t version).

ACE_UINT64	strtoull (const char s, char *ptr, int base)
	Converts a string to a unsigned 64 bit int value (char version).

ACE_UINT64	strtoull (const wchar_t s, wchar_t *ptr, int base)
	Converts a string to a unsigned 64 bit int value (wchar_t version).

int	system (const ACE_TCHAR *s)
	Function that is called by <ACE_OS::exit>, if non-null.

const char *	getprogname ()

const char *	getprogname_emulation ()
	Function that is called by <ACE_OS::exit>, if non-null.

void	setprogname (const char *name)

void	setprogname_emulation (const char *name)
	Function that is called by <ACE_OS::exit>, if non-null.

Detailed Description

This namespace defines an OS independent programming API that shields developers from nonportable aspects of writing efficient system programs on Win32, POSIX and other versions of UNIX, and various real-time operating systems.

This class is a wrapper for the XTI/TLI operations.

This namespace encapsulates the differences between various OS platforms. When porting ACE to a new platform, this class is the place to focus on. Once this file is ported to a new platform, pretty much everything else comes for "free." See docs/ACE-porting.html for instructions on porting ACE. Please see the README file in this directory for complete information on the meaning of the various macros.

Typedef Documentation

◆ WChar

typedef ACE_WCHAR_T ACE_OS::WChar

Enumeration Type Documentation

◆ ACE_HRTimer_Op

enum ACE_OS::ACE_HRTimer_Op

Enumerator
ACE_HRTIMER_START
ACE_HRTIMER_INCR
ACE_HRTIMER_STOP
ACE_HRTIMER_GETTIME

Function Documentation

◆ _exit()

void ACE_OS::_exit ( int status = 0 )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ abort()

void ACE_OS::abort ( )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ accept() [1/2]

ACE_HANDLE ACE_OS::accept	(	ACE_HANDLE	handle,
		struct sockaddr *	addr,
		int *	addrlen )

inline

BSD-style accept (no QoS).

◆ accept() [2/2]

ACE_HANDLE ACE_OS::accept	(	ACE_HANDLE	handle,
		struct sockaddr *	addr,
		int *	addrlen,
		const ACE_Accept_QoS_Params &	qos_params )

extern

QoS-enabled accept, which passes qos_params to accept. If the OS platform doesn't support QoS-enabled accept then the qos_params are ignored and the BSD-style accept is called.

◆ access() [1/2]

int ACE_OS::access	(	const char *	path,
		int	amode )

inline

◆ access() [2/2]

int ACE_OS::access	(	const wchar_t *	path,
		int	amode )

inline

◆ ace_isalnum()

int ACE_OS::ace_isalnum ( ACE_TCHAR c )

inline

Returns true if the character is an alphanumeric character.

◆ ace_isalpha()

int ACE_OS::ace_isalpha ( ACE_TCHAR c )

inline

Returns true if the character is an alphabetic character.

◆ ace_isascii()

int ACE_OS::ace_isascii ( ACE_TCHAR c )

inline

Returns true if the character is a control character.

◆ ace_isblank()

int ACE_OS::ace_isblank ( ACE_TCHAR c )

inline

Returns true if the character is a control character.

◆ ace_iscntrl()

int ACE_OS::ace_iscntrl ( ACE_TCHAR c )

inline

Returns true if the character is a control character.

◆ ace_isctype()

int ACE_OS::ace_isctype	(	int	c,
		ctype_t	desc )

inline

Tests c for the property specified by the desc argument.

◆ ace_isdigit()

int ACE_OS::ace_isdigit ( ACE_TCHAR c )

inline

Returns true if the character is a decimal-digit character.

◆ ace_isgraph()

int ACE_OS::ace_isgraph ( ACE_TCHAR c )

inline

Returns true if the character is a printable character other than a space.

◆ ace_islower()

int ACE_OS::ace_islower ( ACE_TCHAR c )

inline

Returns true if the character is a lowercase character.

◆ ace_isprint()

int ACE_OS::ace_isprint ( ACE_TCHAR c )

inline

Returns true if the character is a printable character.

◆ ace_ispunct()

int ACE_OS::ace_ispunct ( ACE_TCHAR c )

inline

Returns true if the character is a punctuation character.

◆ ace_isspace()

int ACE_OS::ace_isspace ( ACE_TCHAR c )

inline

Returns true if the character is a space character.

◆ ace_isupper()

int ACE_OS::ace_isupper ( ACE_TCHAR c )

inline

Returns true if the character is an uppercase character.

◆ ace_iswctype()

int ACE_OS::ace_iswctype	(	wint_t	c,
		wctype_t	desc )

inline

Tests c for the property specified by the desc argument.

◆ ace_isxdigit()

int ACE_OS::ace_isxdigit ( ACE_TCHAR c )

inline

Returns true if the character is a hexadecimal-digit character.

◆ ace_tolower()

int ACE_OS::ace_tolower ( int c )

inline

Converts a character to lower case (char version).

◆ ace_toupper()

int ACE_OS::ace_toupper ( int c )

inline

Converts a character to upper case (char version).

◆ ace_towlower()

wint_t ACE_OS::ace_towlower ( wint_t c )

inline

Converts a character to lower case (wchar_t version).

◆ ace_towupper()

wint_t ACE_OS::ace_towupper ( wint_t c )

inline

Converts a character to upper case (wchar_t version).

◆ alarm()

u_int ACE_OS::alarm ( u_int secs )

inline

◆ allocation_granularity()

long ACE_OS::allocation_granularity ( )

inline

◆ alphasort()

int ACE_OS::alphasort	(	const void *	a,
		const void *	b )

inline

◆ argv_to_string() [1/2]

int ACE_OS::argv_to_string	(	ACE_TCHAR **	argv,
		ACE_TCHAR *&	buf,
		bool	substitute_env_args = true,
		bool	quote_args = false )

extern

◆ argv_to_string() [2/2]

int ACE_OS::argv_to_string	(	int	argc,
		ACE_TCHAR **	argv,
		ACE_TCHAR *&	buf,
		bool	substitute_env_args = true,
		bool	quote_args = false )

extern

used by ARGV::argv_to_string() and ACE_OS::fork_exec()

◆ asctime()

char * ACE_OS::asctime ( const struct tm * tm )

inline

◆ asctime_r()

char * ACE_OS::asctime_r	(	const struct tm *	tm,
		char *	buf,
		int	buflen )

inline

◆ asprintf() [1/2]

int ACE_OS::asprintf	(	char **	bufp,
		const char *	format,
			... )

extern

◆ asprintf() [2/2]

int ACE_OS::asprintf	(	wchar_t **	bufp,
		const wchar_t *	format,
			... )

extern

◆ atexit()

int ACE_OS::atexit	(	ACE_EXIT_HOOK	func,
		const char *	name = 0 )

inline

Register an at exit hook. The name can be used to analyze shutdown problems

◆ atof() [1/2]

double ACE_OS::atof ( const char * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atof() [2/2]

double ACE_OS::atof ( const wchar_t * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atoi() [1/2]

int ACE_OS::atoi ( const char * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atoi() [2/2]

int ACE_OS::atoi ( const wchar_t * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atol() [1/2]

long ACE_OS::atol ( const char * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atol() [2/2]

long ACE_OS::atol ( const wchar_t * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atop() [1/2]

void * ACE_OS::atop ( const char * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ atop() [2/2]

void * ACE_OS::atop ( const wchar_t * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ bind()

int ACE_OS::bind	(	ACE_HANDLE	s,
		struct sockaddr *	name,
		int	namelen )

inline

◆ bsearch()

void * ACE_OS::bsearch	(	const void *	key,
		const void *	base,
		size_t	nel,
		size_t	size,
		ACE_COMPARE_FUNC	compar )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ calloc()

void * ACE_OS::calloc	(	size_t	elements,
		size_t	sizeof_elements )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ ceil()

template<typename T >

T ACE_OS::ceil ( T x )

inline

This method computes the smallest integral value not less than x.

◆ chdir() [1/2]

int ACE_OS::chdir ( const char * path )

inline

◆ chdir() [2/2]

int ACE_OS::chdir ( const wchar_t * path )

inline

◆ cleanup_tss()

void ACE_OS::cleanup_tss ( const u_int main_thread )

extern

Call TSS destructors for the current thread. If the current thread is the main thread, then the argument must be 1. For private use of ACE_Object_Manager and ACE_Thread_Adapter only.

◆ clearerr()

void ACE_OS::clearerr ( FILE * fp )

inline

◆ clock_gettime()

int ACE_OS::clock_gettime	(	clockid_t	clockid,
		struct timespec *	ts )

inline

◆ clock_settime()

int ACE_OS::clock_settime	(	clockid_t	clockid,
		const struct timespec *	ts )

inline

◆ close()

int ACE_OS::close ( ACE_HANDLE handle )

inline

◆ closedir()

void ACE_OS::closedir ( ACE_DIR * d )

inline

◆ closesocket()

int ACE_OS::closesocket ( ACE_HANDLE s )

inline

Takes care of windows specific requirement to call closesocket.

◆ compile()

char * ACE_OS::compile	(	const char *	instring,
		char *	expbuf,
		char *	endbuf )

inline

◆ cond_broadcast()

int ACE_OS::cond_broadcast ( ACE_cond_t * cv )

inline

◆ cond_destroy()

int ACE_OS::cond_destroy ( ACE_cond_t * cv )

inline

◆ cond_init() [1/4]

int ACE_OS::cond_init	(	ACE_cond_t *	cv,
		ACE_condattr_t &	attributes,
		const char *	name = 0,
		void *	arg = 0 )

inline

◆ cond_init() [2/4]

int ACE_OS::cond_init	(	ACE_cond_t *	cv,
		ACE_condattr_t &	attributes,
		const wchar_t *	name,
		void *	arg = 0 )

inline

◆ cond_init() [3/4]

int ACE_OS::cond_init	(	ACE_cond_t *	cv,
		short	type,
		const wchar_t *	name,
		void *	arg = 0 )

inline

◆ cond_init() [4/4]

int ACE_OS::cond_init	(	ACE_cond_t *	cv,
		short	type = ACE_DEFAULT_SYNCH_TYPE,
		const char *	name = 0,
		void *	arg = 0 )

extern

◆ cond_signal()

int ACE_OS::cond_signal ( ACE_cond_t * cv )

inline

◆ cond_timedwait()

int ACE_OS::cond_timedwait	(	ACE_cond_t *	cv,
		ACE_mutex_t *	m,
		ACE_Time_Value *	timeout )

inline

◆ cond_wait()

int ACE_OS::cond_wait	(	ACE_cond_t *	cv,
		ACE_mutex_t *	m )

inline

◆ condattr_destroy()

int ACE_OS::condattr_destroy ( ACE_condattr_t & attributes )

inline

◆ condattr_init()

int ACE_OS::condattr_init	(	ACE_condattr_t &	attributes,
		int	type = ACE_DEFAULT_SYNCH_TYPE )

inline

◆ condattr_setclock()

int ACE_OS::condattr_setclock	(	ACE_condattr_t &	attributes,
		clockid_t	clock_id )

inline

◆ condattr_synctype()

int ACE_OS::condattr_synctype	(	ACE_condattr_t &	attributes,
		int &	type )

inline

◆ connect() [1/2]

int ACE_OS::connect	(	ACE_HANDLE	handle,
		const sockaddr *	addr,
		int	addrlen,
		const ACE_QoS_Params &	qos_params )

extern

QoS-enabled connect, which passes qos_params to connect. If the OS platform doesn't support QoS-enabled connect then the qos_params are ignored and the BSD-style connect is called.

◆ connect() [2/2]

int ACE_OS::connect	(	ACE_HANDLE	handle,
		struct sockaddr *	addr,
		int	addrlen )

inline

BSD-style connect (no QoS).

◆ creat()

ACE_HANDLE ACE_OS::creat	(	const ACE_TCHAR *	filename,
		mode_t	mode )

inline

◆ ctime()

ACE_TCHAR * ACE_OS::ctime ( const time_t * t )

inline

◆ ctime_r()

ACE_TCHAR * ACE_OS::ctime_r	(	const time_t *	clock,
		ACE_TCHAR *	buf,
		int	buflen )

inline

◆ cuserid() [1/2]

char * ACE_OS::cuserid	(	char *	user,
		size_t	maxlen = ACE_MAX_USERID )

inline

◆ cuserid() [2/2]

wchar_t * ACE_OS::cuserid	(	wchar_t *	user,
		size_t	maxlen = ACE_MAX_USERID )

inline

◆ default_win32_security_attributes()

LPSECURITY_ATTRIBUTES ACE_OS::default_win32_security_attributes ( LPSECURITY_ATTRIBUTES )

inline

Default Win32 Security Attributes definition.

◆ default_win32_security_attributes_r()

LPSECURITY_ATTRIBUTES ACE_OS::default_win32_security_attributes_r	(	LPSECURITY_ATTRIBUTES	,
		LPSECURITY_ATTRIBUTES	,
		SECURITY_DESCRIPTOR *	)

inline

◆ difftime()

double ACE_OS::difftime	(	time_t	t1,
		time_t	t0 )

inline

◆ dlclose()

int ACE_OS::dlclose ( ACE_SHLIB_HANDLE handle )

inline

◆ dlerror()

ACE_TCHAR * ACE_OS::dlerror ( )

inline

◆ dlopen()

ACE_SHLIB_HANDLE ACE_OS::dlopen	(	const ACE_TCHAR *	filename,
		int	mode = ACE_DEFAULT_SHLIB_MODE )

inline

◆ dlsym()

void * ACE_OS::dlsym	(	ACE_SHLIB_HANDLE	handle,
		const ACE_TCHAR *	symbol )

inline

◆ dup() [1/2]

ACE_HANDLE ACE_OS::dup ( ACE_HANDLE handle )

inline

◆ dup() [2/2]

ACE_HANDLE ACE_OS::dup	(	ACE_HANDLE	handle,
		pid_t	pid )

inline

◆ dup2()

int ACE_OS::dup2	(	ACE_HANDLE	oldfd,
		ACE_HANDLE	newfd )

inline

◆ endpwent()

void ACE_OS::endpwent ( )

inline

◆ enum_protocols()

int ACE_OS::enum_protocols	(	int *	protocols,
		ACE_Protocol_Info *	protocol_buffer,
		u_long *	buffer_length )

inline

Retrieve information about available transport protocols installed on the local machine. Windows specific...

◆ event_destroy()

int ACE_OS::event_destroy ( ACE_event_t * event )

extern

◆ event_init() [1/4]

int ACE_OS::event_init	(	ACE_event_t *	event,
		int	manual_reset,
		int	initial_state,
		int	type,
		const wchar_t *	name,
		void *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ event_init() [2/4]

int ACE_OS::event_init	(	ACE_event_t *	event,
		int	manual_reset = 0,
		int	initial_state = 0,
		int	type = ACE_DEFAULT_SYNCH_TYPE,
		const char *	name = 0,
		void *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ event_init() [3/4]

int ACE_OS::event_init	(	ACE_event_t *	event,
		int	type,
		ACE_condattr_t *	attributes,
		int	manual_reset,
		int	initial_state,
		const wchar_t *	name,
		void *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ event_init() [4/4]

int ACE_OS::event_init	(	ACE_event_t *	event,
		int	type,
		ACE_condattr_t *	attributes,
		int	manual_reset = 0,
		int	initial_state = 0,
		const char *	name = 0,
		void *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0 )

extern

◆ event_pulse()

int ACE_OS::event_pulse ( ACE_event_t * event )

extern

◆ event_reset()

int ACE_OS::event_reset ( ACE_event_t * event )

extern

◆ event_signal()

int ACE_OS::event_signal ( ACE_event_t * event )

extern

◆ event_timedwait()

int ACE_OS::event_timedwait	(	ACE_event_t *	event,
		ACE_Time_Value *	timeout,
		int	use_absolute_time = 1 )

extern

◆ event_wait()

int ACE_OS::event_wait ( ACE_event_t * event )

inline

◆ execl()

int ACE_OS::execl	(	const char *	path,
		const char *	arg0,
			... )

extern

◆ execle()

int ACE_OS::execle	(	const char *	path,
		const char *	arg0,
			... )

extern

◆ execlp()

int ACE_OS::execlp	(	const char *	file,
		const char *	arg0,
			... )

extern

◆ execv()

int ACE_OS::execv	(	const char *	path,
		char *const	argv[] )

inline

◆ execve()

int ACE_OS::execve	(	const char *	path,
		char *const	argv[],
		char *const	envp[] )

inline

◆ execvp()

int ACE_OS::execvp	(	const char *	file,
		char *const	argv[] )

inline

◆ exit()

void ACE_OS::exit ( int status = 0 )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ fattach()

int ACE_OS::fattach	(	int	handle,
		const char *	path )

inline

◆ fclose()

int ACE_OS::fclose ( FILE * fp )

inline

◆ fcntl()

int ACE_OS::fcntl	(	ACE_HANDLE	handle,
		int	cmd,
		long	arg = 0 )

inline

◆ fdetach()

int ACE_OS::fdetach ( const char * file )

inline

◆ fdopen()

FILE * ACE_OS::fdopen	(	ACE_HANDLE	handle,
		const ACE_TCHAR *	mode )

inline

◆ fflush()

int ACE_OS::fflush ( FILE * fp )

inline

◆ fgetc()

int ACE_OS::fgetc ( FILE * fp )

inline

◆ fgetpos()

int ACE_OS::fgetpos	(	FILE *	fp,
		fpos_t *	pos )

inline

◆ fgets() [1/2]

char * ACE_OS::fgets	(	char *	buf,
		int	size,
		FILE *	fp )

inline

◆ fgets() [2/2]

wchar_t * ACE_OS::fgets	(	wchar_t *	buf,
		int	size,
		FILE *	fp )

inline

◆ fgetwc()

wint_t ACE_OS::fgetwc ( FILE * fp )

inline

◆ fileno()

ACE_HANDLE ACE_OS::fileno ( FILE * stream )

inline

◆ filesize() [1/2]

ACE_OFF_T ACE_OS::filesize ( ACE_HANDLE handle )

inline

◆ filesize() [2/2]

ACE_OFF_T ACE_OS::filesize ( const ACE_TCHAR * handle )

inline

◆ flock_adjust_params()

void ACE_OS::flock_adjust_params	(	ACE_OS::ace_flock_t *	lock,
		short	whence,
		ACE_OFF_T &	start,
		ACE_OFF_T &	len )

inline

◆ flock_destroy()

int ACE_OS::flock_destroy	(	ACE_OS::ace_flock_t *	lock,
		int	unlink_file = 1 )

inline

◆ flock_init()

int ACE_OS::flock_init	(	ACE_OS::ace_flock_t *	lock,
		int	flags = 0,
		const ACE_TCHAR *	name = 0,
		mode_t	perms = 0 )

inline

◆ flock_rdlock()

int ACE_OS::flock_rdlock	(	ACE_OS::ace_flock_t *	lock,
		short	whence = 0,
		ACE_OFF_T	start = 0,
		ACE_OFF_T	len = 0 )

inline

◆ flock_tryrdlock()

int ACE_OS::flock_tryrdlock	(	ACE_OS::ace_flock_t *	lock,
		short	whence = 0,
		ACE_OFF_T	start = 0,
		ACE_OFF_T	len = 0 )

inline

◆ flock_trywrlock()

int ACE_OS::flock_trywrlock	(	ACE_OS::ace_flock_t *	lock,
		short	whence = 0,
		ACE_OFF_T	start = 0,
		ACE_OFF_T	len = 0 )

inline

◆ flock_unlock()

int ACE_OS::flock_unlock	(	ACE_OS::ace_flock_t *	lock,
		short	whence = 0,
		ACE_OFF_T	start = 0,
		ACE_OFF_T	len = 0 )

inline

◆ flock_wrlock()

int ACE_OS::flock_wrlock	(	ACE_OS::ace_flock_t *	lock,
		short	whence = 0,
		ACE_OFF_T	start = 0,
		ACE_OFF_T	len = 0 )

inline

◆ floor()

template<typename T >

T ACE_OS::floor ( T x )

inline

This method computes the largest integral value not greater than x.

◆ fopen() [1/4]

FILE * ACE_OS::fopen	(	const char *	filename,
		const char *	mode )

extern

◆ fopen() [2/4]

FILE * ACE_OS::fopen	(	const char *	filename,
		const wchar_t *	mode )

extern

◆ fopen() [3/4]

FILE * ACE_OS::fopen	(	const wchar_t *	filename,
		const char *	mode )

extern

◆ fopen() [4/4]

FILE * ACE_OS::fopen	(	const wchar_t *	filename,
		const wchar_t *	mode )

extern

◆ fork() [1/2]

pid_t ACE_OS::fork ( )

inline

Forks and exec's a process in a manner that works Windows. argv[0] must be the full path name to the executable.

◆ fork() [2/2]

pid_t ACE_OS::fork ( const ACE_TCHAR * program_name )

extern

◆ fork_exec()

pid_t ACE_OS::fork_exec ( ACE_TCHAR * argv[] )

extern

◆ fprintf() [1/2]

int ACE_OS::fprintf	(	FILE *	fp,
		const char *	format,
			... )

extern

◆ fprintf() [2/2]

int ACE_OS::fprintf	(	FILE *	fp,
		const wchar_t *	format,
			... )

extern

◆ fputc()

int ACE_OS::fputc	(	int	c,
		FILE *	fp )

inline

◆ fputs() [1/2]

int ACE_OS::fputs	(	const char *	s,
		FILE *	stream )

inline

◆ fputs() [2/2]

int ACE_OS::fputs	(	const wchar_t *	s,
		FILE *	stream )

inline

◆ fread()

size_t ACE_OS::fread	(	void *	ptr,
		size_t	size,
		size_t	nelems,
		FILE *	fp )

inline

◆ free()

void ACE_OS::free ( void * ptr )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ freeaddrinfo()

void ACE_OS::freeaddrinfo ( addrinfo * result )

inline

◆ freopen()

FILE * ACE_OS::freopen	(	const ACE_TCHAR *	filename,
		const ACE_TCHAR *	mode,
		FILE *	stream )

inline

◆ fseek()

int ACE_OS::fseek	(	FILE *	fp,
		long	offset,
		int	ptrname )

inline

◆ fsetpos()

int ACE_OS::fsetpos	(	FILE *	fp,
		fpos_t *	pos )

inline

◆ fstat()

int ACE_OS::fstat	(	ACE_HANDLE	handle,
		ACE_stat *	stp )

inline

◆ fsync()

int ACE_OS::fsync ( ACE_HANDLE handle )

inline

◆ ftell()

long ACE_OS::ftell ( FILE * fp )

inline

◆ ftruncate()

int ACE_OS::ftruncate	(	ACE_HANDLE	handle,
		ACE_OFF_T	offset )

inline

◆ fwrite()

size_t ACE_OS::fwrite	(	const void *	ptr,
		size_t	size,
		size_t	nitems,
		FILE *	fp )

inline

◆ gai_strerror()

const ACE_TCHAR * ACE_OS::gai_strerror ( int errcode )

inline

◆ get_win32_resource_module()

HINSTANCE ACE_OS::get_win32_resource_module ( )

inline

Return the handle of the module containing ACE's resources. By default, for a DLL build of ACE this is a handle to the ACE DLL itself, and for a static build it is a handle to the executable.

◆ get_win32_versioninfo()

const ACE_TEXT_OSVERSIONINFO & ACE_OS::get_win32_versioninfo ( )

inline

Return the win32 OSVERSIONINFO structure.

◆ getaddrinfo()

int ACE_OS::getaddrinfo	(	const char *	name,
		const char *	service,
		const addrinfo *	hints,
		addrinfo **	result )

inline

◆ getc()

int ACE_OS::getc ( FILE * fp )

inline

◆ getcwd() [1/2]

char * ACE_OS::getcwd	(	char *	buf,
		size_t	size )

inline

◆ getcwd() [2/2]

wchar_t * ACE_OS::getcwd	(	wchar_t *	buf,
		size_t	size )

inline

◆ getegid()

gid_t ACE_OS::getegid ( )

inline

◆ getenv() [1/2]

char * ACE_OS::getenv ( const char * symbol )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ getenv() [2/2]

wchar_t * ACE_OS::getenv ( const wchar_t * symbol )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ getenvstrings()

ACE_TCHAR * ACE_OS::getenvstrings ( )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ geteuid()

uid_t ACE_OS::geteuid ( )

inline

◆ getgid()

gid_t ACE_OS::getgid ( )

inline

◆ gethostbyaddr()

struct hostent * ACE_OS::gethostbyaddr	(	const char *	addr,
		int	length,
		int	type )

inline

◆ gethostbyaddr_r()

struct hostent * ACE_OS::gethostbyaddr_r	(	const char *	addr,
		int	length,
		int	type,
		struct hostent *	result,
		ACE_HOSTENT_DATA	buffer,
		int *	h_errnop )

inline

◆ gethostbyname()

struct hostent * ACE_OS::gethostbyname ( const char * name )

inline

◆ gethostbyname_r()

struct hostent * ACE_OS::gethostbyname_r	(	const char *	name,
		struct hostent *	result,
		ACE_HOSTENT_DATA	buffer,
		int *	h_errnop )

inline

◆ gethrtime()

ACE_hrtime_t ACE_OS::gethrtime ( const ACE_HRTimer_Op op = ACE_HRTIMER_GETTIME )

inline

◆ getipnodebyaddr()

struct hostent * ACE_OS::getipnodebyaddr	(	const void *	src,
		size_t	len,
		int	family )

inline

◆ getipnodebyname()

struct hostent * ACE_OS::getipnodebyname	(	const char *	name,
		int	family,
		int	flags = 0 )

inline

◆ getmacaddress()

int ACE_OS::getmacaddress ( struct macaddr_node_t * node )

extern

Define a structure for use with the netbios routine

Reset the netbios

◆ getmsg()

int ACE_OS::getmsg	(	ACE_HANDLE	handle,
		struct strbuf *	ctl,
		struct strbuf *	data,
		int *	flags )

inline

◆ getnameinfo()

int ACE_OS::getnameinfo	(	const sockaddr *	addr,
		ACE_SOCKET_LEN	addr_len,
		char *	host,
		ACE_SOCKET_LEN	host_len,
		char *	service,
		ACE_SOCKET_LEN	service_len,
		unsigned int	flags )

inline

◆ getopt()

int ACE_OS::getopt	(	int	argc,
		char const	argv,
		const char *	optstring )

inline

◆ getpagesize()

long ACE_OS::getpagesize ( )

inline

◆ getpeername()

int ACE_OS::getpeername	(	ACE_HANDLE	handle,
		struct sockaddr *	addr,
		int *	addrlen )

inline

◆ getpgid()

pid_t ACE_OS::getpgid ( pid_t pid )

inline

◆ getpid()

pid_t ACE_OS::getpid ( )

inline

◆ getpmsg()

int ACE_OS::getpmsg	(	ACE_HANDLE	handle,
		struct strbuf *	ctl,
		struct strbuf *	data,
		int *	band,
		int *	flags )

inline

◆ getppid()

pid_t ACE_OS::getppid ( )

inline

◆ getprogname()

const char * ACE_OS::getprogname ( )

inline

Get the name of the current program

Originally from NetBSD, now found in *BSD, Cygwin, Darwin, etc.

◆ getprogname_emulation()

const char * ACE_OS::getprogname_emulation ( )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ getprotobyname()

struct protoent * ACE_OS::getprotobyname ( const char * name )

inline

◆ getprotobyname_r()

struct protoent * ACE_OS::getprotobyname_r	(	const char *	name,
		struct protoent *	result,
		ACE_PROTOENT_DATA	buffer )

inline

◆ getprotobynumber()

struct protoent * ACE_OS::getprotobynumber ( int proto )

inline

◆ getprotobynumber_r()

struct protoent * ACE_OS::getprotobynumber_r	(	int	proto,
		struct protoent *	result,
		ACE_PROTOENT_DATA	buffer )

inline

◆ getpwent()

struct passwd * ACE_OS::getpwent ( )

inline

◆ getpwnam()

struct passwd * ACE_OS::getpwnam ( const char * user )

inline

◆ getpwnam_r()

int ACE_OS::getpwnam_r	(	const char *	name,
		struct passwd *	pwd,
		char *	buffer,
		size_t	bufsize,
		struct passwd **	result )

inline

◆ getrlimit()

int ACE_OS::getrlimit	(	int	resource,
		struct rlimit *	rl )

inline

◆ getrusage()

int ACE_OS::getrusage	(	int	who,
		struct rusage *	rusage )

inline

◆ getservbyname()

struct servent * ACE_OS::getservbyname	(	const char *	svc,
		const char *	proto )

inline

◆ getservbyname_r()

struct servent * ACE_OS::getservbyname_r	(	const char *	svc,
		const char *	proto,
		struct servent *	result,
		ACE_SERVENT_DATA	buf )

inline

◆ getsockname()

int ACE_OS::getsockname	(	ACE_HANDLE	handle,
		struct sockaddr *	addr,
		int *	addrlen )

inline

◆ getsockopt()

int ACE_OS::getsockopt	(	ACE_HANDLE	handle,
		int	level,
		int	optname,
		char *	optval,
		int *	optlen )

inline

◆ gettimeofday()

ACE_Time_Value ACE_OS::gettimeofday ( )

inline

◆ gettimeofday_()

ACE_Time_Value ACE_OS::gettimeofday_ ( )

inline

◆ getuid()

uid_t ACE_OS::getuid ( )

inline

◆ gmtime()

struct tm * ACE_OS::gmtime ( const time_t * clock )

inline

◆ gmtime_r()

struct tm * ACE_OS::gmtime_r	(	const time_t *	clock,
		struct tm *	res )

inline

◆ hostname() [1/2]

int ACE_OS::hostname	(	char	name[],
		size_t	maxnamelen )

inline

◆ hostname() [2/2]

int ACE_OS::hostname	(	wchar_t	name[],
		size_t	maxnamelen )

inline

◆ if_freenameindex()

void ACE_OS::if_freenameindex ( struct if_nameindex * ptr )

inline

◆ if_indextoname()

char * ACE_OS::if_indextoname	(	unsigned int	ifindex,
		char *	ifname )

inline

◆ if_nameindex()

struct if_nameindex * ACE_OS::if_nameindex ( )

inline

◆ if_nametoindex()

unsigned int ACE_OS::if_nametoindex ( const char * ifname )

inline

◆ inet_addr()

unsigned long ACE_OS::inet_addr ( const char * name )

inline

◆ inet_aton()

int ACE_OS::inet_aton	(	const char *	strptr,
		struct in_addr *	addr )

extern

◆ inet_ntoa()

char * ACE_OS::inet_ntoa ( const struct in_addr addr )

inline

◆ inet_ntop()

const char * ACE_OS::inet_ntop	(	int	family,
		const void *	addrptr,
		char *	strptr,
		size_t	len )

inline

◆ inet_pton()

int ACE_OS::inet_pton	(	int	family,
		const char *	strptr,
		void *	addrptr )

inline

◆ ioctl() [1/3]

int ACE_OS::ioctl	(	ACE_HANDLE	handle,
		ACE_IOCTL_TYPE_ARG2	cmd,
		void *	val = 0 )

inline

UNIX-style ioctl.

◆ ioctl() [2/3]

int ACE_OS::ioctl	(	ACE_HANDLE	socket,
		unsigned long	io_control_code,
		ACE_QoS &	ace_qos,
		unsigned long *	bytes_returned,
		void *	buffer_p = 0,
		unsigned long	buffer = 0,
		ACE_OVERLAPPED *	overlapped = 0,
		ACE_OVERLAPPED_COMPLETION_FUNC	func = 0 )

extern

QoS-enabled ioctl when the I/O control code is either SIO_SET_QOS or SIO_GET_QOS.

◆ ioctl() [3/3]

int ACE_OS::ioctl	(	ACE_HANDLE	socket,
		unsigned long	io_control_code,
		void *	in_buffer_p,
		unsigned long	in_buffer,
		void *	out_buffer_p,
		unsigned long	out_buffer,
		unsigned long *	bytes_returned,
		ACE_OVERLAPPED *	overlapped,
		ACE_OVERLAPPED_COMPLETION_FUNC	func )

extern

QoS-enabled ioctl.

◆ isastream()

int ACE_OS::isastream ( ACE_HANDLE handle )

inline

◆ isatty() [1/2]

int ACE_OS::isatty ( ACE_HANDLE handle )

inline

◆ isatty() [2/2]

int ACE_OS::isatty ( int handle )

inline

◆ itoa() [1/2]

char * ACE_OS::itoa	(	int	value,
		char *	string,
		int	radix )

inline

Converts an integer to a string.

◆ itoa() [2/2]

wchar_t * ACE_OS::itoa	(	int	value,
		wchar_t *	string,
		int	radix )

inline

Converts an integer to a string.

◆ itoa_emulation()

char * ACE_OS::itoa_emulation	(	int	value,
		char *	string,
		int	radix )

extern

Emulated itoa - Converts an integer to a string.

◆ join_leaf()

ACE_HANDLE ACE_OS::join_leaf	(	ACE_HANDLE	socket,
		const sockaddr *	name,
		int	namelen,
		const ACE_QoS_Params &	qos_params )

extern

Joins a leaf node into a QoS-enabled multi-point session.

◆ kill()

int ACE_OS::kill	(	pid_t	pid,
		int	signum )

inline

◆ last_error() [1/2]

int ACE_OS::last_error ( )

inline

◆ last_error() [2/2]

void ACE_OS::last_error ( int error )

inline

◆ listen()

int ACE_OS::listen	(	ACE_HANDLE	handle,
		int	backlog )

inline

◆ localtime()

struct tm * ACE_OS::localtime ( const time_t * clock )

inline

◆ localtime_r()

struct tm * ACE_OS::localtime_r	(	const time_t *	clock,
		struct tm *	res )

extern

◆ log2()

double ACE_OS::log2 ( double x )

inline

This method computes the base-2 logarithm of x.

◆ lseek()

ACE_OFF_T ACE_OS::lseek	(	ACE_HANDLE	handle,
		ACE_OFF_T	offset,
		int	whence )

inline

◆ lstat() [1/2]

int ACE_OS::lstat	(	const char *	file,
		ACE_stat *	stp )

inline

◆ lstat() [2/2]

int ACE_OS::lstat	(	const wchar_t *	file,
		ACE_stat *	stp )

inline

◆ lwp_getparams()

int ACE_OS::lwp_getparams ( ACE_Sched_Params & sched_params )

extern

◆ lwp_setparams()

int ACE_OS::lwp_setparams ( const ACE_Sched_Params & sched_params )

extern

◆ madvise()

int ACE_OS::madvise	(	caddr_t	addr,
		size_t	len,
		int	map_advice )

inline

◆ malloc()

void * ACE_OS::malloc ( size_t nbytes )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ memchr() [1/2]

const void * ACE_OS::memchr	(	const void *	s,
		int	c,
		size_t	len )

inline

Finds characters in a buffer (const void version).

◆ memchr() [2/2]

void * ACE_OS::memchr	(	void *	s,
		int	c,
		size_t	len )

inline

Finds characters in a buffer (void version).

◆ memcmp()

int ACE_OS::memcmp	(	const void *	t,
		const void *	s,
		size_t	len )

inline

Compares two buffers.

◆ memcpy()

void * ACE_OS::memcpy	(	void *	t,
		const void *	s,
		size_t	len )

inline

Copies one buffer to another.

◆ memmove()

void * ACE_OS::memmove	(	void *	t,
		const void *	s,
		size_t	len )

inline

Moves one buffer to another.

◆ memset()

void * ACE_OS::memset	(	void *	s,
		int	c,
		size_t	len )

inline

Fills a buffer with a character value.

◆ mkdir() [1/2]

int ACE_OS::mkdir	(	const char *	path,
		mode_t	mode = ACE_DEFAULT_DIR_PERMS )

inline

◆ mkdir() [2/2]

int ACE_OS::mkdir	(	const wchar_t *	path,
		mode_t	mode = ACE_DEFAULT_DIR_PERMS )

inline

◆ mkfifo()

int ACE_OS::mkfifo	(	const ACE_TCHAR *	file,
		mode_t	mode = ACE_DEFAULT_FILE_PERMS )

inline

◆ mkstemp() [1/2]

ACE_HANDLE ACE_OS::mkstemp ( char * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ mkstemp() [2/2]

ACE_HANDLE ACE_OS::mkstemp ( wchar_t * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ mktemp() [1/2]

char * ACE_OS::mktemp ( char * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ mktemp() [2/2]

wchar_t * ACE_OS::mktemp ( wchar_t * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ mktime()

time_t ACE_OS::mktime ( struct tm * timeptr )

extern

◆ mmap()

void * ACE_OS::mmap	(	void *	addr,
		size_t	len,
		int	prot,
		int	flags,
		ACE_HANDLE	handle,
		ACE_OFF_T	off = 0,
		ACE_HANDLE *	file_mapping = 0,
		LPSECURITY_ATTRIBUTES	sa = 0,
		const ACE_TCHAR *	file_mapping_name = 0 )

inline

◆ mprotect()

int ACE_OS::mprotect	(	void *	addr,
		size_t	len,
		int	prot )

inline

◆ msgctl()

int ACE_OS::msgctl	(	int	msqid,
		int	cmd,
		struct msqid_ds *	val )

inline

◆ msgget()

int ACE_OS::msgget	(	key_t	key,
		int	msgflg )

inline

◆ msgrcv()

ssize_t ACE_OS::msgrcv	(	int	int_id,
		void *	buf,
		size_t	len,
		long	type,
		int	flags )

inline

◆ msgsnd()

int ACE_OS::msgsnd	(	int	int_id,
		const void *	buf,
		size_t	len,
		int	flags )

inline

◆ msync()

int ACE_OS::msync	(	void *	addr,
		size_t	len,
		int	sync )

inline

◆ munmap()

int ACE_OS::munmap	(	void *	addr,
		size_t	len )

inline

◆ mutex_destroy()

int ACE_OS::mutex_destroy ( ACE_mutex_t * m )

extern

◆ mutex_init() [1/2]

int ACE_OS::mutex_init	(	ACE_mutex_t *	m,
		int	lock_scope,
		const wchar_t *	name,
		ACE_mutexattr_t *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0,
		int	lock_type = 0 )

extern

◆ mutex_init() [2/2]

int ACE_OS::mutex_init	(	ACE_mutex_t *	m,
		int	lock_scope = ACE_DEFAULT_SYNCH_TYPE,
		const char *	name = 0,
		ACE_mutexattr_t *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0,
		int	lock_type = 0 )

extern

◆ mutex_lock() [1/4]

int ACE_OS::mutex_lock ( ACE_mutex_t * m )

extern

Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership.

◆ mutex_lock() [2/4]

int ACE_OS::mutex_lock	(	ACE_mutex_t *	m,
		const ACE_Time_Value &	timeout )

extern

This method attempts to acquire a lock, but gives up if the lock has not been acquired by the given time. If the lock is not acquired within the given amount of time, then this method returns -1 with an ETIME errno on platforms that actually support timed mutexes. The timeout should be an absolute time. Note that the mutex should not be a recursive one, i.e., it should only be a standard mutex or an error checking mutex since some implementations of this method don't support recursive mutexes. If you want to use a recursive mutex see the methods below.

◆ mutex_lock() [3/4]

int ACE_OS::mutex_lock	(	ACE_mutex_t *	m,
		const ACE_Time_Value *	timeout )

inline

If timeout == 0, calls <ACE_OS::mutex_lock(m)>. Otherwise, this method attempts to acquire a lock, but gives up if the lock has not been acquired by the given time, in which case it returns -1 with an ETIME errno on platforms that actually support timed mutexes. The timeout should be an absolute time. Note that the mutex should not be a recursive one, i.e., it should only be a standard mutex or an error checking mutex since some implementations of this method don't support recursive mutexes. If you want to use a recursive mutex see the methods below.

◆ mutex_lock() [4/4]

int ACE_OS::mutex_lock	(	ACE_mutex_t *	m,
		int &	abandoned )

extern

This method is only implemented for Win32. For abandoned mutexes, abandoned is set to 1 and 0 is returned.

◆ mutex_lock_cleanup()

void ACE_OS::mutex_lock_cleanup ( void * mutex )

extern

Handle asynchronous thread cancellation cleanup.

◆ mutex_trylock() [1/2]

int ACE_OS::mutex_trylock ( ACE_mutex_t * m )

extern

Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership.

◆ mutex_trylock() [2/2]

int ACE_OS::mutex_trylock	(	ACE_mutex_t *	m,
		int &	abandoned )

extern

This method is only implemented for Win32. For abandoned mutexes, abandoned is set to 1 and 0 is returned.

◆ mutex_unlock()

int ACE_OS::mutex_unlock ( ACE_mutex_t * m )

extern

◆ nanosleep()

int ACE_OS::nanosleep	(	const struct timespec *	requested,
		struct timespec *	remaining = 0 )

inline

◆ num_processors()

long ACE_OS::num_processors ( )

extern

Get the number of CPUs configured in the machine.

◆ num_processors_online()

long ACE_OS::num_processors_online ( )

extern

Get the number of CPUs currently online.

◆ open() [1/2]

ACE_HANDLE ACE_OS::open	(	const char *	filename,
		int	mode,
		mode_t	perms = ACE_DEFAULT_OPEN_PERMS,
		LPSECURITY_ATTRIBUTES	sa = 0 )

extern

The O_APPEND flag is only partly supported on Win32. If you specify O_APPEND, then the file pointer will be positioned at the end of the file initially during open, but it is not re-positioned at the end prior to each write, as specified by POSIX. This is generally good enough for typical situations, but it is `‘not quite right’' in its semantics.

◆ open() [2/2]

ACE_HANDLE ACE_OS::open	(	const wchar_t *	filename,
		int	mode,
		mode_t	perms = ACE_DEFAULT_OPEN_PERMS,
		LPSECURITY_ATTRIBUTES	sa = 0 )

extern

◆ opendir()

ACE_DIR * ACE_OS::opendir ( const ACE_TCHAR * filename )

inline

◆ perror() [1/2]

void ACE_OS::perror ( const char * s )

inline

◆ perror() [2/2]

void ACE_OS::perror ( const wchar_t * s )

inline

◆ pipe()

int ACE_OS::pipe ( ACE_HANDLE handles[] )

inline

◆ poll() [1/2]

int ACE_OS::poll	(	struct pollfd *	pollfds,
		unsigned long	len,
		const ACE_Time_Value &	tv )

inline

◆ poll() [2/2]

int ACE_OS::poll	(	struct pollfd *	pollfds,
		unsigned long	len,
		const ACE_Time_Value *	tv = 0 )

inline

◆ posix_devctl()

int ACE_OS::posix_devctl	(	int	filedes,
		int	dcmd,
		void *	dev_data_ptr,
		size_t	nbyte,
		int *	dev_info_ptr )

inline

◆ pread()

ssize_t ACE_OS::pread	(	ACE_HANDLE	handle,
		void *	buf,
		size_t	nbyte,
		ACE_OFF_T	offset )

extern

◆ printf() [1/2]

int ACE_OS::printf	(	const char *	format,
			... )

extern

◆ printf() [2/2]

int ACE_OS::printf	(	const wchar_t *	format,
			... )

extern

◆ priority_control()

long ACE_OS::priority_control	(	ACE_idtype_t	,
		ACE_id_t	,
		int	,
		void *	)

inline

Low-level interface to priocntl(2).

◆ pthread_sigmask()

int ACE_OS::pthread_sigmask	(	int	how,
		const sigset_t *	nsp,
		sigset_t *	osp )

inline

◆ putc()

int ACE_OS::putc	(	int	c,
		FILE *	fp )

inline

◆ putenv() [1/2]

int ACE_OS::putenv ( const char * string )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ putenv() [2/2]

int ACE_OS::putenv ( const wchar_t * string )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ putmsg()

int ACE_OS::putmsg	(	ACE_HANDLE	handle,
		const struct strbuf *	ctl,
		const struct strbuf *	data,
		int	flags )

inline

◆ putpmsg()

int ACE_OS::putpmsg	(	ACE_HANDLE	handle,
		const struct strbuf *	ctl,
		const struct strbuf *	data,
		int	band,
		int	flags )

inline

◆ puts() [1/2]

int ACE_OS::puts ( const char * s )

inline

◆ puts() [2/2]

int ACE_OS::puts ( const wchar_t * s )

inline

◆ pwrite()

ssize_t ACE_OS::pwrite	(	ACE_HANDLE	handle,
		const void *	buf,
		size_t	nbyte,
		ACE_OFF_T	offset )

extern

◆ qsort()

void ACE_OS::qsort	(	void *	base,
		size_t	nel,
		size_t	width,
		ACE_COMPARE_FUNC	compar )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ raise()

int ACE_OS::raise ( const int signum )

inline

◆ rand()

int ACE_OS::rand ( )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ rand_r()

int ACE_OS::rand_r ( unsigned int * seed )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ read() [1/2]

ssize_t ACE_OS::read	(	ACE_HANDLE	handle,
		void *	buf,
		size_t	len )

inline

◆ read() [2/2]

ssize_t ACE_OS::read	(	ACE_HANDLE	handle,
		void *	buf,
		size_t	len,
		ACE_OVERLAPPED *	overlapped )

inline

◆ read_n()

ssize_t ACE_OS::read_n	(	ACE_HANDLE	handle,
		void *	buf,
		size_t	len,
		size_t *	bytes_transferred = 0 )

extern

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.

◆ readdir()

struct ACE_DIRENT * ACE_OS::readdir ( ACE_DIR * d )

inline

◆ readlink()

ssize_t ACE_OS::readlink	(	const char *	path,
		char *	buf,
		size_t	bufsiz )

inline

◆ readv()

ssize_t ACE_OS::readv	(	ACE_HANDLE	handle,
		const iovec *	iov,
		int	iovlen )

inline

◆ realloc()

void * ACE_OS::realloc	(	void *	ptr,
		size_t	nbytes )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ realpath() [1/2]

char * ACE_OS::realpath	(	const char *	file_name,
		char *	resolved_name )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ realpath() [2/2]

wchar_t * ACE_OS::realpath	(	const wchar_t *	file_name,
		wchar_t *	resolved_name )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ recursive_mutex_cond_relock()

void ACE_OS::recursive_mutex_cond_relock	(	ACE_recursive_thread_mutex_t *	m,
		ACE_recursive_mutex_state &	state )

inline

◆ recursive_mutex_cond_unlock()

int ACE_OS::recursive_mutex_cond_unlock	(	ACE_recursive_thread_mutex_t *	m,
		ACE_recursive_mutex_state &	state )

inline

◆ recursive_mutex_destroy()

int ACE_OS::recursive_mutex_destroy ( ACE_recursive_thread_mutex_t * m )

inline

◆ recursive_mutex_init()

int ACE_OS::recursive_mutex_init	(	ACE_recursive_thread_mutex_t *	m,
		const ACE_TCHAR *	name = 0,
		ACE_mutexattr_t *	arg = 0,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ recursive_mutex_lock() [1/3]

int ACE_OS::recursive_mutex_lock ( ACE_recursive_thread_mutex_t * m )

inline

◆ recursive_mutex_lock() [2/3]

int ACE_OS::recursive_mutex_lock	(	ACE_recursive_thread_mutex_t *	m,
		const ACE_Time_Value &	timeout )

inline

◆ recursive_mutex_lock() [3/3]

int ACE_OS::recursive_mutex_lock	(	ACE_recursive_thread_mutex_t *	m,
		const ACE_Time_Value *	timeout )

inline

◆ recursive_mutex_trylock()

int ACE_OS::recursive_mutex_trylock ( ACE_recursive_thread_mutex_t * m )

inline

◆ recursive_mutex_unlock()

int ACE_OS::recursive_mutex_unlock ( ACE_recursive_thread_mutex_t * m )

inline

◆ recv()

ssize_t ACE_OS::recv	(	ACE_HANDLE	handle,
		char *	buf,
		size_t	len,
		int	flags = 0 )

inline

◆ recvfrom() [1/2]

ssize_t ACE_OS::recvfrom	(	ACE_HANDLE	handle,
		char *	buf,
		size_t	len,
		int	flags,
		struct sockaddr *	addr,
		int *	addrlen )

inline

◆ recvfrom() [2/2]

ssize_t ACE_OS::recvfrom	(	ACE_HANDLE	handle,
		iovec *	buffers,
		int	buffer_count,
		size_t &	number_of_bytes_recvd,
		int &	flags,
		struct sockaddr *	addr,
		int *	addrlen,
		ACE_OVERLAPPED *	overlapped,
		ACE_OVERLAPPED_COMPLETION_FUNC	func )

inline

◆ recvmsg()

ssize_t ACE_OS::recvmsg	(	ACE_HANDLE	handle,
		struct msghdr *	msg,
		int	flags )

inline

◆ recvv()

ssize_t ACE_OS::recvv	(	ACE_HANDLE	handle,
		iovec *	iov,
		int	iovlen )

inline

◆ rename() [1/2]

int ACE_OS::rename	(	const char *	old_name,
		const char *	new_name,
		int	flags = -1 )

inline

◆ rename() [2/2]

int ACE_OS::rename	(	const wchar_t *	old_name,
		const wchar_t *	new_name,
		int	flags = -1 )

inline

◆ rewind()

void ACE_OS::rewind ( FILE * fp )

inline

◆ rewinddir()

void ACE_OS::rewinddir ( ACE_DIR * d )

inline

◆ rmdir() [1/2]

int ACE_OS::rmdir ( const char * path )

inline

◆ rmdir() [2/2]

int ACE_OS::rmdir ( const wchar_t * path )

inline

◆ rw_rdlock()

int ACE_OS::rw_rdlock ( ACE_rwlock_t * rw )

inline

◆ rw_tryrdlock()

int ACE_OS::rw_tryrdlock ( ACE_rwlock_t * rw )

inline

◆ rw_trywrlock()

int ACE_OS::rw_trywrlock ( ACE_rwlock_t * rw )

inline

◆ rw_trywrlock_upgrade()

int ACE_OS::rw_trywrlock_upgrade ( ACE_rwlock_t * rw )

inline

◆ rw_unlock()

int ACE_OS::rw_unlock ( ACE_rwlock_t * rw )

inline

◆ rw_wrlock()

int ACE_OS::rw_wrlock ( ACE_rwlock_t * rw )

inline

◆ rwlock_destroy()

int ACE_OS::rwlock_destroy ( ACE_rwlock_t * rw )

inline

◆ rwlock_init()

int ACE_OS::rwlock_init	(	ACE_rwlock_t *	rw,
		int	type = ACE_DEFAULT_SYNCH_TYPE,
		const ACE_TCHAR *	name = 0,
		void *	arg = 0 )

externinline

◆ sbrk()

void * ACE_OS::sbrk ( intptr_t brk )

inline

◆ scandir()

int ACE_OS::scandir	(	const ACE_TCHAR *	dirname,
		struct ACE_DIRENT **	namelist[],
		ACE_SCANDIR_SELECTOR	selector,
		ACE_SCANDIR_COMPARATOR	comparator )

inline

◆ scandir_emulation()

int ACE_OS::scandir_emulation	(	const ACE_TCHAR *	dirname,
		ACE_DIRENT **	namelist[],
		ACE_SCANDIR_SELECTOR	selector,
		ACE_SCANDIR_COMPARATOR	comparator )

extern

◆ sched_params()

int ACE_OS::sched_params	(	const ACE_Sched_Params &	sched_params,
		ACE_id_t	id = ACE_SELF )

extern

Set scheduling parameters. An id of ACE_SELF indicates, e.g., set the parameters on the calling thread.

◆ scheduling_class()

int ACE_OS::scheduling_class	(	const char *	class_name,
		ACE_id_t &	)

extern

Find the scheduling class ID that corresponds to the class name.

◆ seekdir()

void ACE_OS::seekdir	(	ACE_DIR *	d,
		long	loc )

inline

◆ select() [1/2]

int ACE_OS::select	(	int	width,
		fd_set *	rfds,
		fd_set *	wfds,
		fd_set *	efds,
		const ACE_Time_Value &	tv )

inline

◆ select() [2/2]

int ACE_OS::select	(	int	width,
		fd_set *	rfds,
		fd_set *	wfds = 0,
		fd_set *	efds = 0,
		const ACE_Time_Value *	tv = 0 )

inline

◆ sema_avoid_unlink()

void ACE_OS::sema_avoid_unlink	(	ACE_sema_t *	s,
		bool	avoid_unlink )

inline

◆ sema_destroy()

int ACE_OS::sema_destroy ( ACE_sema_t * s )

inline

◆ sema_init() [1/4]

int ACE_OS::sema_init	(	ACE_sema_t *	s,
		u_int	count,
		int	type,
		ACE_condattr_t *	attributes,
		const char *	name = 0,
		void *	arg = 0,
		int	max = 0x7fffffff,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ sema_init() [2/4]

int ACE_OS::sema_init	(	ACE_sema_t *	s,
		u_int	count,
		int	type,
		ACE_condattr_t *	attributes,
		const wchar_t *	name,
		void *	arg = 0,
		int	max = 0x7fffffff,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ sema_init() [3/4]

int ACE_OS::sema_init	(	ACE_sema_t *	s,
		u_int	count,
		int	type,
		const wchar_t *	name,
		void *	arg = 0,
		int	max = 0x7fffffff,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ sema_init() [4/4]

int ACE_OS::sema_init	(	ACE_sema_t *	s,
		u_int	count,
		int	type = ACE_DEFAULT_SYNCH_TYPE,
		const char *	name = 0,
		void *	arg = 0,
		int	max = 0x7fffffff,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ sema_post() [1/2]

int ACE_OS::sema_post ( ACE_sema_t * s )

inline

◆ sema_post() [2/2]

int ACE_OS::sema_post	(	ACE_sema_t *	s,
		u_int	release_count )

inline

◆ sema_trywait()

int ACE_OS::sema_trywait ( ACE_sema_t * s )

inline

◆ sema_unlink()

int ACE_OS::sema_unlink ( const char * name )

inline

◆ sema_wait() [1/3]

int ACE_OS::sema_wait ( ACE_sema_t * s )

inline

◆ sema_wait() [2/3]

int ACE_OS::sema_wait	(	ACE_sema_t *	s,
		ACE_Time_Value &	tv )

inline

◆ sema_wait() [3/3]

int ACE_OS::sema_wait	(	ACE_sema_t *	s,
		ACE_Time_Value *	tv )

inline

◆ semctl()

int ACE_OS::semctl	(	int	int_id,
		int	semnum,
		int	cmd,
		semun	value )

inline

◆ semget()

int ACE_OS::semget	(	key_t	key,
		int	nsems,
		int	flags )

inline

◆ semop()

int ACE_OS::semop	(	int	int_id,
		struct sembuf *	sops,
		size_t	nsops )

inline

◆ send()

ssize_t ACE_OS::send	(	ACE_HANDLE	handle,
		const char *	buf,
		size_t	len,
		int	flags = 0 )

inline

◆ send_partial_i()

ssize_t ACE_OS::send_partial_i	(	ACE_HANDLE	handle,
		const char *	buf,
		size_t	len,
		int	flags )

extern

internal function used by send when an ENOBUFS condition requires a buffer to do a partial send

◆ sendfile()

ssize_t ACE_OS::sendfile	(	ACE_HANDLE	out_fd,
		ACE_HANDLE	in_fd,
		off_t *	offset,
		size_t	count )

inline

Wrapper for sendfile to transfer data between file descriptor.

◆ sendmsg()

ssize_t ACE_OS::sendmsg	(	ACE_HANDLE	handle,
		const struct msghdr *	msg,
		int	flags )

inline

◆ sendto() [1/2]

ssize_t ACE_OS::sendto	(	ACE_HANDLE	handle,
		const char *	buf,
		size_t	len,
		int	flags,
		const struct sockaddr *	addr,
		int	addrlen )

inline

◆ sendto() [2/2]

ssize_t ACE_OS::sendto	(	ACE_HANDLE	handle,
		const iovec *	buffers,
		int	buffer_count,
		size_t &	number_of_bytes_sent,
		int	flags,
		const struct sockaddr *	addr,
		int	addrlen,
		ACE_OVERLAPPED *	overlapped,
		ACE_OVERLAPPED_COMPLETION_FUNC	func )

inline

◆ sendv()

ssize_t ACE_OS::sendv	(	ACE_HANDLE	handle,
		const iovec *	iov,
		int	iovcnt )

inline

◆ sendv_partial_i()

ssize_t ACE_OS::sendv_partial_i	(	ACE_HANDLE	handle,
		const iovec *	iov,
		int	iovcnt )

extern

internal function used by sendv when an ENOBUFS condition requires a buffer to do a partial send

◆ set_errno_to_last_error()

int ACE_OS::set_errno_to_last_error ( )

inline

◆ set_errno_to_wsa_last_error()

int ACE_OS::set_errno_to_wsa_last_error ( )

inline

◆ set_exit_hook()

ACE_EXIT_HOOK ACE_OS::set_exit_hook ( ACE_EXIT_HOOK hook )

inline

For use by ACE_Object_Manager only, to register its exit hook..

◆ set_scheduling_params()

int ACE_OS::set_scheduling_params	(	const ACE_Sched_Params &	,
		ACE_id_t	id = ACE_SELF )

extern

Friendly interface to priocntl(2).

◆ set_win32_resource_module()

void ACE_OS::set_win32_resource_module ( HINSTANCE )

inline

Allow an application to modify which module contains ACE's resources. This is mainly useful for a static build of ACE where the required resources reside somewhere other than the executable.

◆ setegid()

int ACE_OS::setegid ( gid_t gid )

inline

◆ setenv()

int ACE_OS::setenv	(	const char *	envname,
		const char *	envval,
		int	overwrite )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ seteuid()

int ACE_OS::seteuid ( uid_t uid )

inline

◆ setgid()

int ACE_OS::setgid ( gid_t gid )

inline

◆ setpgid()

int ACE_OS::setpgid	(	pid_t	pid,
		pid_t	pgid )

inline

◆ setprogname()

void ACE_OS::setprogname ( const char * name )

inline

Set the name of the current program

Originally from NetBSD, now found in *BSD, Cygwin, Darwin, etc.

◆ setprogname_emulation()

void ACE_OS::setprogname_emulation ( const char * name )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ setpwent()

void ACE_OS::setpwent ( )

inline

◆ setregid()

int ACE_OS::setregid	(	gid_t	rgid,
		gid_t	egid )

inline

◆ setreuid()

int ACE_OS::setreuid	(	uid_t	ruid,
		uid_t	euid )

inline

◆ setrlimit()

int ACE_OS::setrlimit	(	int	resource,
		const struct rlimit *	rl )

inline

◆ setsid()

pid_t ACE_OS::setsid ( )

inline

◆ setsockopt()

int ACE_OS::setsockopt	(	ACE_HANDLE	handle,
		int	level,
		int	optname,
		const char *	optval,
		int	optlen )

inline

Manipulate the options associated with a socket.

◆ setuid()

int ACE_OS::setuid ( uid_t uid )

inline

◆ shm_open()

ACE_HANDLE ACE_OS::shm_open	(	const ACE_TCHAR *	filename,
		int	mode,
		mode_t	perms = 0,
		LPSECURITY_ATTRIBUTES	sa = 0 )

inline

◆ shm_unlink()

int ACE_OS::shm_unlink ( const ACE_TCHAR * path )

inline

◆ shmat()

void * ACE_OS::shmat	(	int	int_id,
		const void *	shmaddr,
		int	shmflg )

inline

◆ shmctl()

int ACE_OS::shmctl	(	int	int_id,
		int	cmd,
		struct shmid_ds *	buf )

inline

◆ shmdt()

int ACE_OS::shmdt ( const void * shmaddr )

inline

◆ shmget()

int ACE_OS::shmget	(	key_t	key,
		size_t	size,
		int	flags )

inline

◆ shutdown()

int ACE_OS::shutdown	(	ACE_HANDLE	handle,
		int	how )

inline

◆ sigaction()

int ACE_OS::sigaction	(	int	signum,
		const ACE_SIGACTION *	nsa,
		ACE_SIGACTION *	osa )

inline

◆ sigaddset()

int ACE_OS::sigaddset	(	sigset_t *	s,
		int	signum )

inline

◆ sigdelset()

int ACE_OS::sigdelset	(	sigset_t *	s,
		int	signum )

inline

◆ sigemptyset()

int ACE_OS::sigemptyset ( sigset_t * s )

inline

◆ sigfillset()

int ACE_OS::sigfillset ( sigset_t * s )

inline

◆ sigismember()

int ACE_OS::sigismember	(	sigset_t *	s,
		int	signum )

inline

◆ signal()

ACE_SignalHandler ACE_OS::signal	(	int	signum,
		ACE_SignalHandler	func )

inline

◆ sigprocmask()

int ACE_OS::sigprocmask	(	int	how,
		const sigset_t *	nsp,
		sigset_t *	osp )

inline

◆ sigsuspend()

int ACE_OS::sigsuspend ( const sigset_t * s )

inline

◆ sigtimedwait()

int ACE_OS::sigtimedwait	(	const sigset_t *	set,
		siginfo_t *	info,
		const ACE_Time_Value *	timeout )

inline

◆ sigwait()

int ACE_OS::sigwait	(	sigset_t *	set,
		int *	sig = 0 )

inline

◆ sigwaitinfo()

int ACE_OS::sigwaitinfo	(	const sigset_t *	set,
		siginfo_t *	info )

inline

◆ sleep() [1/2]

int ACE_OS::sleep ( const ACE_Time_Value & tv )

inline

◆ sleep() [2/2]

int ACE_OS::sleep ( u_int seconds )

inline

◆ snprintf() [1/2]

int ACE_OS::snprintf	(	char *	buf,
		size_t	maxlen,
		const char *	format,
			... )

extern

◆ snprintf() [2/2]

int ACE_OS::snprintf	(	wchar_t *	buf,
		size_t	maxlen,
		const wchar_t *	format,
			... )

extern

◆ socket() [1/2]

ACE_HANDLE ACE_OS::socket	(	int	protocol_family,
		int	type,
		int	proto )

inline

Create a BSD-style socket (no QoS).

◆ socket() [2/2]

ACE_HANDLE ACE_OS::socket	(	int	protocol_family,
		int	type,
		int	proto,
		ACE_Protocol_Info *	protocolinfo,
		ACE_SOCK_GROUP	g,
		u_long	flags )

inline

Create a QoS-enabled socket. If the OS platform doesn't support QoS-enabled <socket> then the BSD-style <socket> is called.

◆ socket_fini()

int ACE_OS::socket_fini ( )

extern

Finalize WinSock after last use (e.g., when a DLL is unloaded).

◆ socket_init()

int ACE_OS::socket_init	(	int	version_high = 1,
		int	version_low = 1 )

extern

Initialize WinSock before first use (e.g., when a DLL is first loaded or the first use of a socket() call.

◆ socketpair()

int ACE_OS::socketpair	(	int	domain,
		int	type,
		int	protocol,
		ACE_HANDLE	sv[2] )

inline

◆ sprintf() [1/2]

int ACE_OS::sprintf	(	char *	buf,
		const char *	format,
			... )

extern

◆ sprintf() [2/2]

int ACE_OS::sprintf	(	wchar_t *	buf,
		const wchar_t *	format,
			... )

extern

◆ srand()

void ACE_OS::srand ( u_int seed )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ stat() [1/2]

int ACE_OS::stat	(	const char *	file,
		ACE_stat *	stp )

inline

◆ stat() [2/2]

int ACE_OS::stat	(	const wchar_t *	file,
		ACE_stat *	stp )

inline

◆ step()

int ACE_OS::step	(	const char *	str,
		char *	expbuf )

inline

◆ strcasecmp() [1/2]

int ACE_OS::strcasecmp	(	const char *	s,
		const char *	t )

inline

Compares two strings (case insensitive const char version).

◆ strcasecmp() [2/2]

int ACE_OS::strcasecmp	(	const wchar_t *	s,
		const wchar_t *	t )

inline

Compares two strings (case insensitive const wchar_t version).

◆ strcat() [1/2]

char * ACE_OS::strcat	(	char *	s,
		const char *	t )

inline

Appends a string to another string (char version).

◆ strcat() [2/2]

wchar_t * ACE_OS::strcat	(	wchar_t *	s,
		const wchar_t *	t )

inline

Appends a string to another string (wchar_t version).

◆ strchr() [1/4]

char * ACE_OS::strchr	(	char *	s,
		int	c )

inline

Finds the first occurrence of a character in a string (char version).

◆ strchr() [2/4]

const char * ACE_OS::strchr	(	const char *	s,
		int	c )

inline

Finds the first occurrence of a character in a string (const char version).

◆ strchr() [3/4]

const wchar_t * ACE_OS::strchr	(	const wchar_t *	s,
		wchar_t	c )

inline

Finds the first occurrence of a character in a string (const wchar_t version).

◆ strchr() [4/4]

wchar_t * ACE_OS::strchr	(	wchar_t *	s,
		wchar_t	c )

inline

Finds the first occurrence of a character in a string (wchar_t version).

◆ strcmp() [1/2]

int ACE_OS::strcmp	(	const ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	t )

inline

Compares two strings (wchar_t version).

◆ strcmp() [2/2]

int ACE_OS::strcmp	(	const char *	s,
		const char *	t )

inline

Compares two strings (char version).

◆ strcpy() [1/2]

char * ACE_OS::strcpy	(	char *	s,
		const char *	t )

inline

Copies a string (char version).

◆ strcpy() [2/2]

wchar_t * ACE_OS::strcpy	(	wchar_t *	s,
		const wchar_t *	t )

inline

Copies a string (wchar_t version).

◆ strcspn() [1/2]

size_t ACE_OS::strcspn	(	const char *	s,
		const char *	reject )

inline

Searches for the first substring without any of the specified characters and returns the size of the substring (char version).

◆ strcspn() [2/2]

size_t ACE_OS::strcspn	(	const wchar_t *	s,
		const wchar_t *	reject )

inline

Searches for the first substring without any of the specified characters and returns the size of the substring (wchar_t version).

◆ strdup() [1/2]

char * ACE_OS::strdup ( const char * s )

inline

Returns a malloced duplicated string (char version).

◆ strdup() [2/2]

wchar_t * ACE_OS::strdup ( const wchar_t * s )

inline

Returns a malloced duplicated string (wchar_t version).

◆ strecpy() [1/2]

char * ACE_OS::strecpy	(	char *	des,
		const char *	src )

extern

Copies a string, but returns a pointer to the end of the copied region (char version).

◆ strecpy() [2/2]

wchar_t * ACE_OS::strecpy	(	wchar_t *	s,
		const wchar_t *	t )

extern

Copies a string, but returns a pointer to the end of the copied region (wchar_t version).

◆ strenvdup()

ACE_TCHAR * ACE_OS::strenvdup ( const ACE_TCHAR * str )

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ strerror()

char * ACE_OS::strerror ( int errnum )

extern

Returns a system error message. If the supplied errnum is out of range, a string of the form "Unknown error %d" is used to format the string whose pointer is returned and errno is set to EINVAL.

◆ strerror_r()

char * ACE_OS::strerror_r	(	int	errnum,
		char *	buf,
		size_t	buflen )

extern

Finds characters in a buffer (const void version).

◆ strftime()

size_t ACE_OS::strftime	(	char *	s,
		size_t	maxsize,
		const char *	format,
		const struct tm *	timeptr )

inline

◆ string_to_argv()

int ACE_OS::string_to_argv	(	ACE_TCHAR *	buf,
		int &	argc,
		ACE_TCHAR **&	argv,
		bool	substitute_env_args = true )

extern

◆ strlen() [1/2]

size_t ACE_OS::strlen ( const ACE_WCHAR_T * s )

inline

Finds the length of a string (ACE_WCHAR_T version).

◆ strlen() [2/2]

size_t ACE_OS::strlen ( const char * s )

inline

Finds the length of a string (char version).

◆ strncasecmp() [1/2]

int ACE_OS::strncasecmp	(	const char *	s,
		const char *	t,
		size_t	len )

inline

Compares two arrays (case insensitive const char version).

◆ strncasecmp() [2/2]

int ACE_OS::strncasecmp	(	const wchar_t *	s,
		const wchar_t *	t,
		size_t	len )

inline

Compares two arrays (case insensitive const wchar_t version).

◆ strncat() [1/2]

ACE_WCHAR_T * ACE_OS::strncat	(	ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	t,
		size_t	len )

inline

Appends part of a string to another string (wchar_t version).

◆ strncat() [2/2]

char * ACE_OS::strncat	(	char *	s,
		const char *	t,
		size_t	len )

inline

Appends part of a string to another string (char version).

◆ strnchr() [1/4]

ACE_WCHAR_T * ACE_OS::strnchr	(	ACE_WCHAR_T *	s,
		ACE_WCHAR_T	c,
		size_t	len )

inline

Finds the first occurrence of a character in an array (ACE_WCHAR_T version).

◆ strnchr() [2/4]

char * ACE_OS::strnchr	(	char *	s,
		int	c,
		size_t	len )

inline

Finds the first occurrence of a character in an array (char version).

◆ strnchr() [3/4]

const ACE_WCHAR_T * ACE_OS::strnchr	(	const ACE_WCHAR_T *	s,
		ACE_WCHAR_T	c,
		size_t	len )

extern

Finds the first occurrence of a character in an array (const ACE_WCHAR_T version).

◆ strnchr() [4/4]

const char * ACE_OS::strnchr	(	const char *	s,
		int	c,
		size_t	len )

extern

Finds the first occurrence of a character in an array (const char version).

◆ strncmp() [1/2]

int ACE_OS::strncmp	(	const ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	t,
		size_t	len )

inline

Compares two arrays (wchar_t version).

◆ strncmp() [2/2]

int ACE_OS::strncmp	(	const char *	s,
		const char *	t,
		size_t	len )

inline

Compares two arrays (char version).

◆ strncpy() [1/2]

ACE_WCHAR_T * ACE_OS::strncpy	(	ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	t,
		size_t	len )

inline

Copies an array (ACE_WCHAR_T version)

◆ strncpy() [2/2]

char * ACE_OS::strncpy	(	char *	s,
		const char *	t,
		size_t	len )

inline

Copies an array (char version)

◆ strnlen() [1/2]

size_t ACE_OS::strnlen	(	const ACE_WCHAR_T *	s,
		size_t	maxlen )

inline

Finds the length of a limited-length string (ACE_WCHAR_T version).

Parameters

s	The character string to find the length of.
maxlen	The maximum number of characters that will be scanned for the terminating nul character.

Returns

The length of

s, if the terminating nul character is located, else
maxlen.

◆ strnlen() [2/2]

size_t ACE_OS::strnlen	(	const char *	s,
		size_t	maxlen )

inline

Finds the length of a limited-length string (char version).

Parameters

s	The character string to find the length of.
maxlen	The maximum number of characters that will be scanned for the terminating nul character.

Returns

The length of

s, if the terminating nul character is located, else
maxlen.

◆ strnstr() [1/4]

ACE_WCHAR_T * ACE_OS::strnstr	(	ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	t,
		size_t	len )

inline

Finds the first occurrence of a substring in an array (wchar_t version).

◆ strnstr() [2/4]

char * ACE_OS::strnstr	(	char *	s,
		const char *	t,
		size_t	len )

inline

Finds the first occurrence of a substring in an array (char version).

◆ strnstr() [3/4]

const ACE_WCHAR_T * ACE_OS::strnstr	(	const ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	t,
		size_t	len )

extern

Finds the first occurrence of a substring in an array (const wchar_t version).

◆ strnstr() [4/4]

const char * ACE_OS::strnstr	(	const char *	s,
		const char *	t,
		size_t	len )

extern

Finds the first occurrence of a substring in an array (const char version).

◆ strpbrk() [1/4]

char * ACE_OS::strpbrk	(	char *	s1,
		const char *	s2 )

inline

Searches for characters in a string (char version).

◆ strpbrk() [2/4]

const char * ACE_OS::strpbrk	(	const char *	s1,
		const char *	s2 )

inline

Searches for characters in a string (const char version).

◆ strpbrk() [3/4]

const wchar_t * ACE_OS::strpbrk	(	const wchar_t *	s1,
		const wchar_t *	s2 )

inline

Searches for characters in a string (const wchar_t version).

◆ strpbrk() [4/4]

wchar_t * ACE_OS::strpbrk	(	wchar_t *	s1,
		const wchar_t *	s2 )

inline

Searches for characters in a string (wchar_t version).

◆ strptime()

char * ACE_OS::strptime	(	const char *	buf,
		const char *	format,
		struct tm *	tm )

inline

strptime wrapper. Note that the struct tm will always be set to zero

◆ strrchr() [1/4]

char * ACE_OS::strrchr	(	char *	s,
		int	c )

inline

Finds the last occurrence of a character in a string (char version).

◆ strrchr() [2/4]

const char * ACE_OS::strrchr	(	const char *	s,
		int	c )

inline

Finds the last occurrence of a character in a string (const char version).

◆ strrchr() [3/4]

const wchar_t * ACE_OS::strrchr	(	const wchar_t *	s,
		wchar_t	c )

inline

Finds the last occurrence of a character in a string (const wchar_t version).

◆ strrchr() [4/4]

wchar_t * ACE_OS::strrchr	(	wchar_t *	s,
		wchar_t	c )

inline

Finds the last occurrence of a character in a string (wchar_t version).

◆ strsignal()

char * ACE_OS::strsignal ( int signum )

extern

Returns a string describing the signal number passed in the argument signum. If the supplied signal number is out of range, a string of the form "Unknown signal %d" is used to format the string whose pointer is returned.

◆ strsncpy() [1/2]

ACE_WCHAR_T * ACE_OS::strsncpy	(	ACE_WCHAR_T *	dst,
		const ACE_WCHAR_T *	src,
		size_t	maxlen )

extern

This is a "safe" c string copy function (wchar_t version).

Unlike strncpy() this function will always add a terminating '\0' char if maxlen > 0. So the user doesn't has to provide an extra '\0' if the user wants a '\0' terminated dst. The function doesn't check for a 0 dst, because this will give problems anyway. When src is 0 an empty string is made. We do not "touch" * dst if maxlen is 0. Returns dst. Care should be taken when replacing strncpy() calls, because in some cases a strncpy() user is using the "not '\0' terminating" feature from strncpy(). This happens most when the call to strncpy() was optimized by using a maxlen which is 1 smaller than the size because there's always written a '\0' inside this last position. Very seldom it's possible that the '\0' padding feature from strncpy() is needed.

◆ strsncpy() [2/2]

char * ACE_OS::strsncpy	(	char *	dst,
		const char *	src,
		size_t	maxlen )

extern

This is a "safe" c string copy function (char version).

Unlike strncpy() this function will always add a terminating '\0' char if maxlen > 0. So the user doesn't has to provide an extra '\0' if the user wants a '\0' terminated dst. The function doesn't check for a 0 dst, because this will give problems anyway. When src is 0 an empty string is made. We do not "touch" * dst if maxlen is 0. Returns dst. Care should be taken when replacing strncpy() calls, because in some cases a strncpy() user is using the "not '\0' terminating" feature from strncpy(). This happens most when the call to strncpy() was optimized by using a maxlen which is 1 smaller than the size because there's always written a '\0' inside this last position. Very seldom it's possible that the '\0' padding feature from strncpy() is needed.

◆ strspn() [1/2]

size_t ACE_OS::strspn	(	const char *	s1,
		const char *	s2 )

inline

Searches for the first substring containing only the specified characters and returns the size of the substring (char version).

◆ strspn() [2/2]

size_t ACE_OS::strspn	(	const wchar_t *	s1,
		const wchar_t *	s2 )

inline

Searches for the first substring containing only the specified characters and returns the size of the substring (wchar_t version).

◆ strstr() [1/4]

char * ACE_OS::strstr	(	char *	s,
		const char *	t )

inline

Finds the first occurrence of a substring in a string (char version).

◆ strstr() [2/4]

const char * ACE_OS::strstr	(	const char *	s,
		const char *	t )

inline

Finds the first occurrence of a substring in a string (const char version).

◆ strstr() [3/4]

const wchar_t * ACE_OS::strstr	(	const wchar_t *	s,
		const wchar_t *	t )

inline

Finds the first occurrence of a substring in a string (const wchar_t version).

◆ strstr() [4/4]

wchar_t * ACE_OS::strstr	(	wchar_t *	s,
		const wchar_t *	t )

inline

Finds the first occurrence of a substring in a string (wchar_t version).

◆ strtod() [1/2]

double ACE_OS::strtod	(	const char *	s,
		char **	endptr )

inline

Converts a string to a double value (char version).

◆ strtod() [2/2]

double ACE_OS::strtod	(	const wchar_t *	s,
		wchar_t **	endptr )

inline

Converts a string to a double value (wchar_t version).

◆ strtok() [1/2]

char * ACE_OS::strtok	(	char *	s,
		const char *	tokens )

inline

Finds the next token in a string (char version).

◆ strtok() [2/2]

wchar_t * ACE_OS::strtok	(	wchar_t *	s,
		const wchar_t *	tokens )

inline

Finds the next token in a string (wchar_t version).

◆ strtok_r() [1/2]

wchar_t * ACE_OS::strtok_r	(	ACE_WCHAR_T *	s,
		const ACE_WCHAR_T *	tokens,
		ACE_WCHAR_T **	lasts )

inline

Finds the next token in a string (wchar_t version).

◆ strtok_r() [2/2]

char * ACE_OS::strtok_r	(	char *	s,
		const char *	tokens,
		char **	lasts )

inline

Finds the next token in a string (safe char version).

◆ strtol() [1/2]

long ACE_OS::strtol	(	const char *	s,
		char **	ptr,
		int	base )

inline

Converts a string to a long value (char version).

◆ strtol() [2/2]

long ACE_OS::strtol	(	const wchar_t *	s,
		wchar_t **	ptr,
		int	base )

inline

Converts a string to a long value (wchar_t version).

◆ strtoll() [1/2]

ACE_INT64 ACE_OS::strtoll	(	const char *	s,
		char **	ptr,
		int	base )

inline

Converts a string to a signed 64 bit int value (char version).

◆ strtoll() [2/2]

ACE_INT64 ACE_OS::strtoll	(	const wchar_t *	s,
		wchar_t **	ptr,
		int	base )

inline

Converts a string to a signed 64 bit int value (wchar_t version).

◆ strtoul() [1/2]

unsigned long ACE_OS::strtoul	(	const char *	s,
		char **	ptr,
		int	base )

inline

Converts a string to an unsigned long value (char version).

◆ strtoul() [2/2]

unsigned long ACE_OS::strtoul	(	const wchar_t *	s,
		wchar_t **	ptr,
		int	base )

inline

Converts a string to an unsigned long value (wchar_t version).

◆ strtoull() [1/2]

ACE_UINT64 ACE_OS::strtoull	(	const char *	s,
		char **	ptr,
		int	base )

inline

Converts a string to a unsigned 64 bit int value (char version).

◆ strtoull() [2/2]

ACE_UINT64 ACE_OS::strtoull	(	const wchar_t *	s,
		wchar_t **	ptr,
		int	base )

inline

Converts a string to a unsigned 64 bit int value (wchar_t version).

◆ swab()

void ACE_OS::swab	(	const void *	src,
		void *	dest,
		ssize_t	n )

inline

◆ sysconf()

long ACE_OS::sysconf ( int name )

inline

◆ sysinfo()

long ACE_OS::sysinfo	(	int	cmd,
		char *	buf,
		long	count )

inline

◆ system()

int ACE_OS::system ( const ACE_TCHAR * s )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ t_accept()

int ACE_OS::t_accept	(	ACE_HANDLE	fildes,
		ACE_HANDLE	resfd,
		struct t_call *	call )

inline

◆ t_alloc()

char * ACE_OS::t_alloc	(	ACE_HANDLE	fildes,
		int	struct_type,
		int	fields )

inline

◆ t_bind()

int ACE_OS::t_bind	(	ACE_HANDLE	fildes,
		ACE_TBIND *	req,
		ACE_TBIND *	ret )

inline

◆ t_close()

int ACE_OS::t_close ( ACE_HANDLE fildes )

inline

◆ t_connect()

int ACE_OS::t_connect	(	ACE_HANDLE	fildes,
		struct t_call *	sndcall,
		struct t_call *	rcvcall )

inline

◆ t_error()

void ACE_OS::t_error ( const char * errmsg )

inline

◆ t_free()

int ACE_OS::t_free	(	char *	ptr,
		int	struct_type )

inline

◆ t_getinfo()

int ACE_OS::t_getinfo	(	ACE_HANDLE	fildes,
		struct t_info *	info )

inline

◆ t_getname()

int ACE_OS::t_getname	(	ACE_HANDLE	fildes,
		struct netbuf *	namep,
		int	type )

inline

◆ t_getstate()

int ACE_OS::t_getstate ( ACE_HANDLE fildes )

inline

◆ t_listen()

int ACE_OS::t_listen	(	ACE_HANDLE	fildes,
		struct t_call *	call )

inline

◆ t_look()

int ACE_OS::t_look ( ACE_HANDLE fildes )

inline

◆ t_open()

ACE_HANDLE ACE_OS::t_open	(	char *	path,
		int	oflag,
		struct t_info *	info )

inline

◆ t_optmgmt()

int ACE_OS::t_optmgmt	(	ACE_HANDLE	handle,
		ACE_TOPTMGMT *	req,
		ACE_TOPTMGMT *	ret )

inline

◆ t_rcv()

int ACE_OS::t_rcv	(	ACE_HANDLE	fildes,
		char *	buf,
		unsigned int	nbytes,
		int *	flags )

inline

◆ t_rcvdis()

int ACE_OS::t_rcvdis	(	ACE_HANDLE	fildes,
		struct t_discon *	discon )

inline

◆ t_rcvrel()

int ACE_OS::t_rcvrel ( ACE_HANDLE fildes )

inline

◆ t_rcvudata()

int ACE_OS::t_rcvudata	(	ACE_HANDLE	fildes,
		struct t_unitdata *	unitdata,
		int *	flags )

inline

◆ t_rcvuderr()

int ACE_OS::t_rcvuderr	(	ACE_HANDLE	fildes,
		struct t_uderr *	uderr )

inline

◆ t_snd()

int ACE_OS::t_snd	(	ACE_HANDLE	fildes,
		const char *	buf,
		unsigned int	nbytes,
		int	flags )

inline

◆ t_snddis()

int ACE_OS::t_snddis	(	ACE_HANDLE	fildes,
		struct t_call *	call )

inline

◆ t_sndrel()

int ACE_OS::t_sndrel ( ACE_HANDLE fildes )

inline

◆ t_sync()

int ACE_OS::t_sync ( ACE_HANDLE fildes )

inline

◆ t_unbind()

int ACE_OS::t_unbind ( ACE_HANDLE fildes )

inline

◆ telldir()

long ACE_OS::telldir ( ACE_DIR * d )

inline

◆ tempnam() [1/2]

char * ACE_OS::tempnam	(	const char *	dir = 0,
		const char *	pfx = 0 )

inline

◆ tempnam() [2/2]

wchar_t * ACE_OS::tempnam	(	const wchar_t *	dir,
		const wchar_t *	pfx = 0 )

inline

◆ thr_cancel()

int ACE_OS::thr_cancel ( ACE_thread_t t_id )

inline

◆ thr_cmp()

int ACE_OS::thr_cmp	(	ACE_hthread_t	t1,
		ACE_hthread_t	t2 )

inline

◆ thr_continue()

int ACE_OS::thr_continue ( ACE_hthread_t target_thread )

inline

◆ thr_create()

int ACE_OS::thr_create	(	ACE_THR_FUNC	func,
		void *	args,
		long	flags,
		ACE_thread_t *	thr_id,
		ACE_hthread_t *	t_handle = 0,
		long	priority = ACE_DEFAULT_THREAD_PRIORITY,
		void *	stack = 0,
		size_t	stacksize = ACE_DEFAULT_THREAD_STACKSIZE,
		ACE_Base_Thread_Adapter *	thread_adapter = 0,
		const char **	thr_name = 0 )

extern

Creates a new thread having flags attributes and running func with args (if thread_adapter is non-0 then func and args are ignored and are obtained from thread_adapter). thr_id and t_handle are set to the thread's ID and handle (?), respectively. The thread runs at priority priority (see below).

The flags are a bitwise-OR of the following: = BEGIN<INDENT> THR_CANCEL_DISABLE, THR_CANCEL_ENABLE, THR_CANCEL_DEFERRED, THR_CANCEL_ASYNCHRONOUS, THR_BOUND, THR_NEW_LWP, THR_DETACHED, THR_SUSPENDED, THR_DAEMON, THR_JOINABLE, THR_SCHED_FIFO, THR_SCHED_RR, THR_SCHED_DEFAULT, THR_EXPLICIT_SCHED, THR_SCOPE_SYSTEM, THR_SCOPE_PROCESS = END<INDENT>

By default, or if priority is set to ACE_DEFAULT_THREAD_PRIORITY, an "appropriate" priority value for the given scheduling policy (specified in flags, e.g., THR_SCHED_DEFAULT) is used. This value is calculated dynamically, and is the median value between the minimum and maximum priority values for the given policy. If an explicit value is given, it is used. Note that actual priority values are EXTREMEMLY implementation-dependent, and are probably best avoided.

Note that thread_adapter is always deleted by thr_create, therefore it must be allocated with global operator new.

At the moment for thr_name a valid string is passed then this will be used on VxWorks to set the task name. If we just pass a pointer the name of the task is returned

◆ thr_equal()

int ACE_OS::thr_equal	(	ACE_thread_t	t1,
		ACE_thread_t	t2 )

inline

◆ thr_exit()

void ACE_OS::thr_exit ( ACE_THR_FUNC_RETURN status = 0 )

extern

◆ thr_get_affinity()

int ACE_OS::thr_get_affinity	(	ACE_hthread_t	thr_id,
		size_t	cpu_set_size,
		cpu_set_t *	cpu_mask )

extern

Get the thread affinity

Parameters

thr_id	For NPTL-threads, when ACE_HAS_PTHREAD_SETAFFINITY_NP defined, this is the thread-id. For linux-threads, when ACE_HAS_SCHED_SETAFFINITY defined, it expects a process-id. Since for linux-threads a thread is seen as a process, it does the job.
cpu_set_size	The size of the cpu_mask, in bytes.
cpu_mask	Is a bitmask of CPUs to bind to, e.g value 1 binds the thread to the "CPU 0", etc

◆ thr_getconcurrency()

int ACE_OS::thr_getconcurrency ( )

inline

◆ thr_getprio() [1/2]

int ACE_OS::thr_getprio	(	ACE_hthread_t	id,
		int &	priority )

inline

◆ thr_getprio() [2/2]

int ACE_OS::thr_getprio	(	ACE_hthread_t	id,
		int &	priority,
		int &	policy )

inline

◆ thr_getspecific()

int ACE_OS::thr_getspecific	(	ACE_thread_key_t	key,
		void **	data )

inline

◆ thr_gettid() [1/2]

pid_t ACE_OS::thr_gettid ( )

inline

For systems that support it (Only Linux as of writing), this is a wrapper for pid_t gettid().

It returns the system-wide thread id (TID) for the current thread. These are similar to PIDs and, for x86 Linux at least, are much shorter than what is returned from thr_self(), which is an address.

For older Linux (pre 2.4.11) and other systems that don't have gettid(), this uses ACE_NOTSUP_RETURN (-1).

◆ thr_gettid() [2/2]

ssize_t ACE_OS::thr_gettid	(	char	buffer[],
		size_t	buffer_length )

inline

Puts the string representation of pid_t thr_gettid() into the buffer and returns number of bytes added.

◆ thr_id()

ssize_t ACE_OS::thr_id	(	char	buffer[],
		size_t	buffer_length )

inline

Stores a string version of the current thread id into buffer and returns the size of this thread id in bytes.

◆ thr_join() [1/2]

int ACE_OS::thr_join	(	ACE_hthread_t	waiter_id,
		ACE_THR_FUNC_RETURN *	status )

inline

◆ thr_join() [2/2]

int ACE_OS::thr_join	(	ACE_thread_t	waiter_id,
		ACE_thread_t *	thr_id,
		ACE_THR_FUNC_RETURN *	status )

inline

◆ thr_key_detach()

int ACE_OS::thr_key_detach ( ACE_thread_key_t key )

extern

◆ thr_key_used()

int ACE_OS::thr_key_used ( ACE_thread_key_t key )

extern

◆ thr_keycreate()

int ACE_OS::thr_keycreate	(	ACE_thread_key_t *	key,
		ACE_THR_DEST	dest )

extern

◆ thr_keyfree()

int ACE_OS::thr_keyfree ( ACE_thread_key_t key )

extern

◆ thr_kill()

int ACE_OS::thr_kill	(	ACE_thread_t	thr_id,
		int	signum )

inline

◆ thr_min_stack()

size_t ACE_OS::thr_min_stack ( )

inline

◆ thr_name()

const char * ACE_OS::thr_name ( )

inline

◆ thr_self() [1/2]

ACE_thread_t ACE_OS::thr_self ( )

inline

◆ thr_self() [2/2]

void ACE_OS::thr_self ( ACE_hthread_t & self )

inline

◆ thr_set_affinity()

int ACE_OS::thr_set_affinity	(	ACE_hthread_t	thr_id,
		size_t	cpu_set_size,
		const cpu_set_t *	cpu_mask )

extern

Set the thread affinity

Parameters

thr_id	For NPTL-threads, when ACE_HAS_PTHREAD_SETAFFINITY_NP defined, this is the thread-id. For linux-threads, when ACE_HAS_SCHED_SETAFFINITY defined, it expects a process-id. Since for linux-threads a thread is seen as a process, it does the job.
cpu_set_size	The size of the cpu_mask, in bytes.
cpu_mask	Is a bitmask of CPUs to bind to, e.g value 1 binds the thread to the "CPU 0", etc

◆ thr_setcancelstate()

int ACE_OS::thr_setcancelstate	(	int	new_state,
		int *	old_state )

inline

State is THR_CANCEL_ENABLE or THR_CANCEL_DISABLE.

◆ thr_setcanceltype()

int ACE_OS::thr_setcanceltype	(	int	new_type,
		int *	old_type )

inline

Type is THR_CANCEL_DEFERRED or THR_CANCEL_ASYNCHRONOUS.

◆ thr_setconcurrency()

int ACE_OS::thr_setconcurrency ( int hint )

inline

◆ thr_setprio() [1/2]

int ACE_OS::thr_setprio	(	ACE_hthread_t	ht_id,
		int	priority,
		int	policy = -1 )

inline

◆ thr_setprio() [2/2]

int ACE_OS::thr_setprio ( const ACE_Sched_Priority prio )

extern

◆ thr_setspecific()

int ACE_OS::thr_setspecific	(	ACE_thread_key_t	key,
		void *	data )

extern

◆ thr_sigsetmask()

int ACE_OS::thr_sigsetmask	(	int	how,
		const sigset_t *	nsm,
		sigset_t *	osm )

inline

◆ thr_suspend()

int ACE_OS::thr_suspend ( ACE_hthread_t target_thread )

inline

◆ thr_testcancel()

void ACE_OS::thr_testcancel ( )

inline

◆ thr_yield()

void ACE_OS::thr_yield ( )

inline

◆ thread_mutex_destroy()

int ACE_OS::thread_mutex_destroy ( ACE_thread_mutex_t * m )

inline

◆ thread_mutex_init() [1/2]

int ACE_OS::thread_mutex_init	(	ACE_thread_mutex_t *	m,
		int	lock_type,
		const wchar_t *	name,
		ACE_mutexattr_t *	arg = 0 )

inline

◆ thread_mutex_init() [2/2]

int ACE_OS::thread_mutex_init	(	ACE_thread_mutex_t *	m,
		int	lock_type = 0,
		const char *	name = 0,
		ACE_mutexattr_t *	arg = 0 )

inline

◆ thread_mutex_lock() [1/3]

int ACE_OS::thread_mutex_lock ( ACE_thread_mutex_t * m )

inline

◆ thread_mutex_lock() [2/3]

int ACE_OS::thread_mutex_lock	(	ACE_thread_mutex_t *	m,
		const ACE_Time_Value &	timeout )

inline

◆ thread_mutex_lock() [3/3]

int ACE_OS::thread_mutex_lock	(	ACE_thread_mutex_t *	m,
		const ACE_Time_Value *	timeout )

inline

◆ thread_mutex_trylock()

int ACE_OS::thread_mutex_trylock ( ACE_thread_mutex_t * m )

inline

◆ thread_mutex_unlock()

int ACE_OS::thread_mutex_unlock ( ACE_thread_mutex_t * m )

inline

◆ time()

time_t ACE_OS::time ( time_t * tloc = 0 )

inline

◆ timezone()

long ACE_OS::timezone ( )

inline

◆ truncate()

int ACE_OS::truncate	(	const ACE_TCHAR *	filename,
		ACE_OFF_T	length )

inline

◆ tzset()

void ACE_OS::tzset ( )

inline

◆ ualarm() [1/2]

useconds_t ACE_OS::ualarm	(	const ACE_Time_Value &	tv,
		const ACE_Time_Value &	tv_interval = ACE_Time_Value::zero )

inline

◆ ualarm() [2/2]

useconds_t ACE_OS::ualarm	(	useconds_t	usecs,
		useconds_t	interval = 0 )

inline

◆ umask()

mode_t ACE_OS::umask ( mode_t cmask )

inline

◆ uname()

int ACE_OS::uname ( ACE_utsname * name )

extern

◆ ungetc()

int ACE_OS::ungetc	(	int	c,
		FILE *	fp )

inline

◆ ungetwc()

wint_t ACE_OS::ungetwc	(	wint_t	c,
		FILE *	fp )

inline

◆ unique_name()

void ACE_OS::unique_name	(	const void *	object,
		char *	name,
		size_t	length )

extern

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.

◆ unlink() [1/2]

int ACE_OS::unlink ( const char * path )

inline

◆ unlink() [2/2]

int ACE_OS::unlink ( const wchar_t * path )

inline

◆ unsetenv()

int ACE_OS::unsetenv ( const char * name )

inline

Function that is called by <ACE_OS::exit>, if non-null.

◆ vasprintf() [1/2]

int ACE_OS::vasprintf	(	char **	bufp,
		const char *	format,
		va_list	argptr )

inline

◆ vasprintf() [2/2]

int ACE_OS::vasprintf	(	wchar_t **	bufp,
		const wchar_t *	format,
		va_list	argptr )

inline

◆ vasprintf_emulation()

int ACE_OS::vasprintf_emulation	(	char **	bufp,
		const char *	format,
		va_list	argptr )

extern

◆ vaswprintf_emulation()

int ACE_OS::vaswprintf_emulation	(	wchar_t **	bufp,
		const wchar_t *	format,
		va_list	argptr )

extern

◆ vfprintf() [1/2]

int ACE_OS::vfprintf	(	FILE *	fp,
		const char *	format,
		va_list	argptr )

inline

◆ vfprintf() [2/2]

int ACE_OS::vfprintf	(	FILE *	fp,
		const wchar_t *	format,
		va_list	argptr )

inline

◆ vprintf() [1/2]

int ACE_OS::vprintf	(	const char *	format,
		va_list	argptr )

inline

◆ vprintf() [2/2]

int ACE_OS::vprintf	(	const wchar_t *	format,
		va_list	argptr )

inline

◆ vsnprintf() [1/2]

int ACE_OS::vsnprintf	(	char *	buffer,
		size_t	maxlen,
		const char *	format,
		va_list	argptr )

inline

◆ vsnprintf() [2/2]

int ACE_OS::vsnprintf	(	wchar_t *	buffer,
		size_t	maxlen,
		const wchar_t *	format,
		va_list	argptr )

inline

◆ vsprintf() [1/2]

int ACE_OS::vsprintf	(	char *	buffer,
		const char *	format,
		va_list	argptr )

inline

◆ vsprintf() [2/2]

int ACE_OS::vsprintf	(	wchar_t *	buffer,
		const wchar_t *	format,
		va_list	argptr )

inline

◆ wait() [1/2]

pid_t ACE_OS::wait ( int * status = 0 )

inline

Calls OS wait function, so it's only portable to UNIX/POSIX platforms.

◆ wait() [2/2]

pid_t ACE_OS::wait	(	pid_t	pid,
		ACE_exitcode *	status,
		int	wait_options = 0,
		ACE_HANDLE	handle = 0 )

inline

Calls ::WaitForSingleObject on Win32 and ACE::waitpid () otherwise. Returns the passed in pid_t on success and -1 on failure. On Win32, pid is ignored if the handle is not equal to 0. Passing the process handle is prefer on Win32 because using pid to wait on the project doesn't always work correctly if the waited process has already terminated.

◆ waitpid()

pid_t ACE_OS::waitpid	(	pid_t	pid,
		ACE_exitcode *	status = 0,
		int	wait_options = 0,
		ACE_HANDLE	handle = 0 )

inline

Calls waitpid on UNIX/POSIX platforms Does not work on VxWorks 5.5.x. On Win32, pid is ignored if the handle is not equal to 0. Passing the process handle is prefer on Win32 because using pid to wait on the project doesn't always work correctly if the waited process has already terminated.

◆ write() [1/2]

ssize_t ACE_OS::write	(	ACE_HANDLE	handle,
		const void *	buf,
		size_t	nbyte )

inline

◆ write() [2/2]

ssize_t ACE_OS::write	(	ACE_HANDLE	handle,
		const void *	buf,
		size_t	nbyte,
		ACE_OVERLAPPED *	overlapped )

inline

◆ write_n()

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

extern

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.

◆ writev()

ssize_t ACE_OS::writev	(	ACE_HANDLE	handle,
		const iovec *	iov,
		int	iovcnt )

inline

◆ wscmp()

int ACE_OS::wscmp	(	const WChar *	s,
		const WChar *	t )

inline

◆ wscpy()

ACE_OS::WChar * ACE_OS::wscpy	(	WChar *	dest,
		const WChar *	src )

inline

◆ wslen()

u_int ACE_OS::wslen ( const WChar * s )

inline

◆ wsncmp()

int ACE_OS::wsncmp	(	const WChar *	s,
		const WChar *	t,
		size_t	len )

inline

Variable Documentation

◆ exit_hook_

ACE_EXIT_HOOK ACE_OS::exit_hook_ = 0

extern

Function that is called by <ACE_OS::exit>, if non-null.

◆ NULL_hthread

ACE_hthread_t ACE_OS::NULL_hthread

extern

This is necessary to deal with POSIX pthreads and their use of structures for thread handles.

◆ NULL_key

ACE_thread_key_t ACE_OS::NULL_key

extern

This is necessary to deal with POSIX pthreads and their use of structures for TSS keys.

◆ NULL_thread

ACE_thread_t ACE_OS::NULL_thread

extern

This is necessary to deal with POSIX pthreads and their use of structures for thread ids.

◆ socket_initialized_

int ACE_OS::socket_initialized_

extern

Keeps track of whether we've already initialized WinSock...

◆ win32_resource_module_

HINSTANCE ACE_OS::win32_resource_module_

extern

◆ win32_versioninfo_

ACE_TEXT_OSVERSIONINFO ACE_OS::win32_versioninfo_

extern

Classes

Typedefs

Enumerations

Functions

Variables

Non-standard functions

Detailed Description

Typedef Documentation

◆ WChar

Enumeration Type Documentation

◆ ACE_HRTimer_Op

Function Documentation

◆ _exit()

◆ abort()

◆ accept() [1/2]

◆ accept() [2/2]

◆ access() [1/2]

◆ access() [2/2]

◆ ace_isalnum()

◆ ace_isalpha()

◆ ace_isascii()

◆ ace_isblank()

◆ ace_iscntrl()

◆ ace_isctype()

◆ ace_isdigit()

◆ ace_isgraph()

◆ ace_islower()

◆ ace_isprint()

◆ ace_ispunct()

◆ ace_isspace()

◆ ace_isupper()

◆ ace_iswctype()

◆ ace_isxdigit()

◆ ace_tolower()

◆ ace_toupper()

◆ ace_towlower()

◆ ace_towupper()

◆ alarm()

◆ allocation_granularity()

◆ alphasort()

◆ argv_to_string() [1/2]

◆ argv_to_string() [2/2]

◆ asctime()

◆ asctime_r()

◆ asprintf() [1/2]

◆ asprintf() [2/2]

◆ atexit()

◆ atof() [1/2]

◆ atof() [2/2]

◆ atoi() [1/2]

◆ atoi() [2/2]

◆ atol() [1/2]

◆ atol() [2/2]

◆ atop() [1/2]

◆ atop() [2/2]

◆ bind()

◆ bsearch()

◆ calloc()

◆ ceil()

◆ chdir() [1/2]

◆ chdir() [2/2]

◆ cleanup_tss()

◆ clearerr()

◆ clock_gettime()

◆ clock_settime()

◆ close()

◆ closedir()

◆ closesocket()

◆ compile()

◆ cond_broadcast()

◆ cond_destroy()

◆ cond_init() [1/4]

◆ cond_init() [2/4]

◆ cond_init() [3/4]

◆ cond_init() [4/4]

◆ cond_signal()

◆ cond_timedwait()

◆ cond_wait()

◆ condattr_destroy()

◆ condattr_init()