Main Page Class Hierarchy Alphabetical List Compound List File List Compound Members File Members Related Pages

# ACE_OS Class Reference

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

`#include <OS.h>`

Inheritance diagram for ACE_OS:

[legend]
Collaboration diagram for ACE_OS:

[legend]
List of all members.

## Wide-character strings
typedef ACE_UINT16 | WChar
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)
## A set of wrappers for threads
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=0, ACE_Base_Thread_Adapter *thread_adapter=0)
int | thr_getprio (ACE_hthread_t thr_id, int &prio)
int | thr_join (ACE_hthread_t waiter_id, void **status)
int | thr_join (ACE_thread_t waiter_id, ACE_thread_t *thr_id, void **status)
int | thr_kill (ACE_thread_t thr_id, int signum)
ACE_thread_t | thr_self (void)
void | thr_self (ACE_hthread_t &)
int | thr_setprio (ACE_hthread_t thr_id, int prio)
int | thr_setprio (const ACE_Sched_Priority prio)
int | thr_suspend (ACE_hthread_t target_thread)
int | thr_cancel (ACE_thread_t t_id)
int | thr_cmp (ACE_hthread_t t1, ACE_hthread_t t2)
int | thr_equal (ACE_thread_t t1, ACE_thread_t t2)
void | thr_exit (void *status=0)
int | thr_getconcurrency (void)
int | lwp_getparams (ACE_Sched_Params &)
int | thr_getspecific (ACE_thread_key_t key, void **data)
int | thr_keyfree (ACE_thread_key_t key)
int | thr_key_detach (void *inst)
int | thr_keycreate (ACE_thread_key_t *key, ACE_THR_DEST, void *inst=0)
int | thr_key_used (ACE_thread_key_t key)
size_t | thr_min_stack (void)
int | thr_setconcurrency (int hint)
int | lwp_setparams (const ACE_Sched_Params &)
int | thr_setspecific (ACE_thread_key_t key, void *data)
int | thr_sigsetmask (int how, const sigset_t *nsm, sigset_t *osm)
int | thr_setcancelstate (int new_state, int *old_state)
int | thr_setcanceltype (int new_type, int *old_type)
int | sigwait (sigset_t *set, int *sig=0)
int | sigtimedwait (const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout)
void | thr_testcancel (void)
void | thr_yield (void)
void | unique_name (const void *object, ACE_TCHAR *name, size_t length)
ACE_thread_t | NULL_thread
| This is necessary to deal with POSIX pthreads and their use of structures for thread ids. More...
ACE_hthread_t | NULL_hthread
| This is necessary to deal with POSIX pthreads and their use of structures for thread handles. More...
ACE_thread_key_t | NULL_key
| This is necessary to deal with POSIX pthreads and their use of structures for TSS keys. More...
## Public Types
enum | ACE_HRTimer_Op { ACE_HRTIMER_START = 0x0, ACE_HRTIMER_INCR = 0x1, ACE_HRTIMER_STOP = 0x2, ACE_HRTIMER_GETTIME = 0xFFFF }
## Static Public Methods
LPSECURITY_ATTRIBUTES | default_win32_security_attributes (LPSECURITY_ATTRIBUTES)
const OSVERSIONINFO & | get_win32_versioninfo (void)
| Return the win32 OSVERSIONINFO structure. More...
HINSTANCE | get_win32_resource_module (void)
| 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. More...
void | set_win32_resource_module (HINSTANCE)
| 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. More...
int | atoi (const char *s)
int | atoi (const wchar_t *s)
double | floor (double x)
| This method computes the largest integral value not greater than x. More...
double | ceil (double x)
| This method computes the smallest integral value not less than x. More...
char * | getenv (const char *symbol)
wchar_t * | getenv (const wchar_t *symbol)
int | putenv (const ACE_TCHAR *string)
ACE_TCHAR * | strenvdup (const ACE_TCHAR *str)
ACE_TCHAR * | getenvstrings (void)
int | getopt (int argc, char *const *argv, const char *optstring)
int | argv_to_string (ACE_TCHAR **argv, ACE_TCHAR *&buf, int substitute_env_args=1)
int | string_to_argv (ACE_TCHAR *buf, size_t &argc, ACE_TCHAR **&argv, int substitute_env_args=1)
long | sysconf (int)
int | last_error (void)
void | last_error (int)
int | set_errno_to_last_error (void)
int | set_errno_to_wsa_last_error (void)
int | fclose (FILE *fp)
int | fcntl (ACE_HANDLE handle, int cmd, long arg=0)
int | fdetach (const char *file)
int | fsync (ACE_HANDLE handle)
FILE * | fopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode)
FILE * | freopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode, FILE *stream)
FILE * | fdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)
ACE_TCHAR * | fgets (ACE_TCHAR *buf, int size, FILE *fp)
int | stat (const ACE_TCHAR *file, ACE_stat *)
int | truncate (const ACE_TCHAR *filename, off_t length)
int | fprintf (FILE *fp, const char *format,...)
int | sprintf (char *buf, const char *format,...)
int | vsprintf (char *buffer, const char *format, va_list argptr)
int | printf (const char *format,...)
int | sprintf (wchar_t *buf, const wchar_t *format,...)
int | fprintf (FILE *fp, const wchar_t *format,...)
int | vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr)
void | perror (const ACE_TCHAR *s)
char * | gets (char *str, int n=0)
int | puts (const ACE_TCHAR *s)
int | fputs (const ACE_TCHAR *s, FILE *stream)
int | fflush (FILE *fp)
size_t | fread (void *ptr, size_t size, size_t nelems, FILE *fp)
int | fseek (FILE *fp, long offset, int ptrname)
int | fstat (ACE_HANDLE, ACE_stat *)
int | lstat (const char *, ACE_stat *)
int | ftruncate (ACE_HANDLE, off_t)
size_t | fwrite (const void *ptr, size_t size, size_t nitems, FILE *fp)
void | rewind (FILE *fp)
int | getpagesize (void)
int | allocation_granularity (void)
gid_t | getgid (void)
int | setgid (gid_t)
pid_t | getpid (void)
pid_t | getpgid (pid_t pid)
pid_t | getppid (void)
uid_t | getuid (void)
int | setuid (uid_t)
pid_t | setsid (void)
int | setpgid (pid_t pid, pid_t pgid)
int | setreuid (uid_t ruid, uid_t euid)
int | setregid (gid_t rgid, gid_t egid)
int | system (const ACE_TCHAR *s)
pid_t | waitpid (pid_t pid, ACE_exitcode *status=0, int wait_options=0, ACE_HANDLE handle=0)
pid_t | wait (pid_t pid, ACE_exitcode *status, int wait_options=0, ACE_HANDLE handle=0)
pid_t | wait (int *=0)
| Calls OS <wait> function, so it's only portable to UNIX/POSIX platforms. More...
void | mutex_lock_cleanup (void *mutex)
| Handle asynchronous thread cancellation cleanup. More...
void | cleanup_tss (const u_int main_thread)
int | scheduling_class (const char *class_name, ACE_id_t &)
| Find the schedling class ID that corresponds to the class name. More...
int | set_scheduling_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
| Friendly interface to <priocntl>(2). More...
int | priority_control (ACE_idtype_t, ACE_id_t, int, void *)
| Low-level interface to <priocntl>(2). More...
A set of wrappers for condition variables.
int | condattr_init (ACE_condattr_t &attributes, int type=ACE_DEFAULT_SYNCH_TYPE)
int | condattr_destroy (ACE_condattr_t &attributes)
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 *)
int | cond_wait (ACE_cond_t *cv, ACE_mutex_t *m)
Wrappers to obtain the current user id
char * | cuserid (char *user, size_t maxlen=ACE_MAX_USERID)
wchar_t * | cuserid (wchar_t *user, size_t maxlen=ACE_MAX_USERID)
Wrappers to obtain configuration info
int | uname (ACE_utsname *name)
long | sysinfo (int cmd, char *buf, long count)
int | hostname (char *name, size_t maxnamelen)
int | hostname (wchar_t *name, size_t maxnamelen)
A set of wrappers for explicit dynamic linking.
int | dlclose (ACE_SHLIB_HANDLE handle)
ACE_TCHAR * | dlerror (void)
ACE_SHLIB_HANDLE | dlopen (const ACE_TCHAR *filename, int mode=ACE_DEFAULT_SHLIB_MODE)
void * | dlsym (ACE_SHLIB_HANDLE handle, const ACE_TCHAR *symbol)
Wrappers for searching and sorting.
void * | bsearch (const void *key, const void *base, size_t nel, size_t size, ACE_COMPARE_FUNC)
void | qsort (void *base, size_t nel, size_t width, ACE_COMPARE_FUNC)
A set of wrappers for file locks.
int | flock_init (ACE_OS::ace_flock_t *lock, int flags=0, const ACE_TCHAR *name=0, mode_t perms=0)
int | flock_destroy (ACE_OS::ace_flock_t *lock, int unlink_file=1)
void | adjust_flock_params (ACE_OS::ace_flock_t *lock, short whence, off_t &start, off_t &len)
int | flock_rdlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int | flock_tryrdlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int | flock_trywrlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int | flock_unlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
int | flock_wrlock (ACE_OS::ace_flock_t *lock, short whence=0, off_t start=0, off_t len=0)
A set of wrappers for low-level process operations.
int | atexit (ACE_EXIT_HOOK func)
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 | execvp (const char *file, char *const argv[])
int | execve (const char *path, char *const argv[], char *const envp[])
void | _exit (int status=0)
void | exit (int status=0)
void | abort (void)
pid_t | fork (void)
pid_t | fork (const ACE_TCHAR *program_name)
| Forks and exec's a process in a manner that works on Solaris and NT. argv[0] must be the full path name to the executable. More...
pid_t | fork_exec (ACE_TCHAR *argv[])
A set of wrappers for timers and resource stats.
u_int | alarm (u_int secs)
u_int | ualarm (u_int usecs, u_int interval=0)
u_int | ualarm (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)
ACE_hrtime_t | gethrtime (const ACE_HRTimer_Op=ACE_HRTIMER_GETTIME)
int | clock_gettime (clockid_t, struct timespec *)
ACE_Time_Value | gettimeofday (void)
int | getrusage (int who, struct rusage *rusage)
int | getrlimit (int resource, struct rlimit *rl)
int | setrlimit (int resource, ACE_SETRLIMIT_TYPE *rl)
int | sleep (u_int seconds)
int | sleep (const ACE_Time_Value &tv)
int | nanosleep (const struct timespec *requested, struct timespec *remaining=0)
A set of wrappers for operations on time.
time_t | mktime (struct tm *timeptr)
void | tzset (void)
long | timezone (void)
double | difftime (time_t t1, time_t t0)
time_t | time (time_t *tloc=0)
tm * | localtime (const time_t *clock)
tm * | localtime_r (const time_t *clock, struct tm *res)
tm * | gmtime (const time_t *clock)
tm * | gmtime_r (const time_t *clock, struct tm *res)
char * | asctime (const struct tm *tm)
char * | asctime_r (const struct tm *tm, char *buf, int buflen)
ACE_TCHAR * | ctime (const time_t *t)
ACE_TCHAR * | ctime_r (const time_t *clock, ACE_TCHAR *buf, int buflen)
size_t | strftime (char *s, size_t maxsize, const char *format, const struct tm *timeptr)
A set of wrappers for System V message queues.
int | msgctl (int msqid, int cmd, struct msqid_ds *)
int | msgget (key_t key, int msgflg)
int | 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)
A set of wrappers for memory mapped files.
int | madvise (caddr_t addr, size_t len, int advice)
void * | mmap (void *addr, size_t len, int prot, int flags, ACE_HANDLE handle, 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)
A set of wrappers for recursive mutex locks.
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_destroy (ACE_recursive_thread_mutex_t *m)
int | recursive_mutex_lock (ACE_recursive_thread_mutex_t *m)
int | recursive_mutex_trylock (ACE_recursive_thread_mutex_t *m)
int | recursive_mutex_unlock (ACE_recursive_thread_mutex_t *m)
A set of wrappers for mutex locks.
int | mutex_init (ACE_mutex_t *m, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int | mutex_init (ACE_mutex_t *m, int type, const wchar_t *name, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int | mutex_destroy (ACE_mutex_t *m)
int | mutex_lock (ACE_mutex_t *m)
| Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership. More...
int | mutex_lock (ACE_mutex_t *m, int &abandoned)
| This method is only implemented for Win32. For abandoned mutexes, <abandoned> is set to 1 and 0 is returned. More...
int | mutex_lock (ACE_mutex_t *m, const ACE_Time_Value &timeout)
int | mutex_lock (ACE_mutex_t *m, const ACE_Time_Value *timeout)
int | mutex_trylock (ACE_mutex_t *m)
| Win32 note: Abandoned mutexes are not treated differently. 0 is returned since the calling thread does get the ownership. More...
int | mutex_trylock (ACE_mutex_t *m, int &abandoned)
| This method is only implemented for Win32. For abandoned mutexes, <abandoned> is set to 1 and 0 is returned. More...
int | mutex_unlock (ACE_mutex_t *m)
A set of wrappers for mutex locks that only work within a single process.
int | thread_mutex_init (ACE_thread_mutex_t *m, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, ACE_mutexattr_t *arg=0)
int | thread_mutex_init (ACE_thread_mutex_t *m, int type, const wchar_t *name, ACE_mutexattr_t *arg=0)
int | thread_mutex_destroy (ACE_thread_mutex_t *m)
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)
A set of wrappers for low-level file operations.
int | access (const char *path, int amode)
int | access (const wchar_t *path, int amode)
int | close (ACE_HANDLE handle)
ACE_HANDLE | creat (const ACE_TCHAR *filename, mode_t mode)
ACE_HANDLE | dup (ACE_HANDLE handle)
int | dup2 (ACE_HANDLE oldfd, ACE_HANDLE newfd)
int | fattach (int handle, const char *path)
long | filesize (ACE_HANDLE handle)
long | filesize (const ACE_TCHAR *handle)
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 | ioctl (ACE_HANDLE handle, int cmd, void *=0)
| UNIX-style <ioctl>. More...
int | ioctl (ACE_HANDLE socket, u_long io_control_code, void *in_buffer_p, u_long in_buffer, void *out_buffer_p, u_long out_buffer, u_long *bytes_returned, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
| QoS-enabled <ioctl>. More...
int | ioctl (ACE_HANDLE socket, u_long io_control_code, ACE_QoS &ace_qos, u_long *bytes_returned, void *buffer_p=0, u_long buffer=0, ACE_OVERLAPPED *overlapped=0, ACE_OVERLAPPED_COMPLETION_FUNC func=0)
| QoS-enabled <ioctl> when the I/O control code is either SIO_SET_QOS or SIO_GET_QOS. More...
int | isastream (ACE_HANDLE handle)
int | isatty (int handle)
int | isatty (ACE_HANDLE handle)
off_t | lseek (ACE_HANDLE handle, off_t offset, int whence)
ACE_HANDLE | open (const char *filename, int mode, int perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
| 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. More...
ACE_HANDLE | open (const wchar_t *filename, int mode, int perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
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)
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)
int | readlink (const char *path, char *buf, size_t bufsiz)
ssize_t | pread (ACE_HANDLE handle, void *buf, size_t nbyte, off_t offset)
int | recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)
int | sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags)
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)
ssize_t | pwrite (ACE_HANDLE handle, const void *buf, size_t nbyte, off_t offset)
ssize_t | readv (ACE_HANDLE handle, iovec *iov, int iovlen)
ssize_t | writev (ACE_HANDLE handle, const iovec *iov, int iovcnt)
ssize_t | recvv (ACE_HANDLE handle, iovec *iov, int iovlen)
ssize_t | sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt)
A set of wrappers for event demultiplexing and IPC.
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)
int | poll (struct pollfd *pollfds, u_long len, const ACE_Time_Value *tv=0)
int | poll (struct pollfd *pollfds, u_long len, const ACE_Time_Value &tv)
int | pipe (ACE_HANDLE handles[])
ACE_HANDLE | shm_open (const ACE_TCHAR *filename, int mode, int perms=0, LPSECURITY_ATTRIBUTES sa=0)
int | shm_unlink (const ACE_TCHAR *path)
A set of wrappers for directory operations.
mode_t | umask (mode_t cmask)
int | chdir (const char *path)
int | chdir (const wchar_t *path)
int | mkdir (const ACE_TCHAR *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)
int | mkfifo (const ACE_TCHAR *file, mode_t mode=ACE_DEFAULT_FILE_PERMS)
ACE_TCHAR * | mktemp (ACE_TCHAR *t)
ACE_HANDLE | mkstemp (ACE_TCHAR *t)
ACE_TCHAR * | getcwd (ACE_TCHAR *, size_t)
int | rename (const ACE_TCHAR *old_name, const ACE_TCHAR *new_name, int flags=-1)
int | unlink (const ACE_TCHAR *path)
ACE_TCHAR * | tempnam (const ACE_TCHAR *dir=0, const ACE_TCHAR *pfx=0)
A set of wrappers for random number operations.
int | rand (void)
int | rand_r (ACE_RANDR_TYPE &seed)
void | srand (u_int seed)
A set of wrappers for readers/writer locks.
int | rwlock_init (ACE_rwlock_t *rw, int type=ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR *name=0, void *arg=0)
int | rwlock_destroy (ACE_rwlock_t *rw)
int | rw_rdlock (ACE_rwlock_t *rw)
int | rw_wrlock (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)
A set of wrappers for auto-reset and manual events.
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 manual_reset, int initial_state, int type, const wchar_t *name, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
int | event_destroy (ACE_event_t *event)
int | event_wait (ACE_event_t *event)
int | event_timedwait (ACE_event_t *event, ACE_Time_Value *timeout, int use_absolute_time=1)
int | event_signal (ACE_event_t *event)
int | event_pulse (ACE_event_t *event)
int | event_reset (ACE_event_t *event)
A set of wrappers for semaphores.
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, const wchar_t *name, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
int | sema_post (ACE_sema_t *s)
int | sema_post (ACE_sema_t *s, size_t 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)
A set of wrappers for System V semaphores.
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)
Thread scheduler interface.
int | sched_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
| Set scheduling parameters. An id of ACE_SELF indicates, e.g., set the parameters on the calling thread. More...
A set of wrappers for System V shared memory.
void * | shmat (int int_id, void *shmaddr, int shmflg)
int | shmctl (int int_id, int cmd, struct shmid_ds *buf)
int | shmdt (void *shmaddr)
int | shmget (key_t key, int size, int flags)
A set of wrappers for Signals.
int | kill (pid_t pid, int signum)
int | sigaction (int signum, const struct sigaction *nsa, struct 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 | sigsuspend (const sigset_t *set)
int | sigprocmask (int how, const sigset_t *nsp, sigset_t *osp)
int | pthread_sigmask (int how, const sigset_t *nsp, sigset_t *osp)
A set of wrappers for sockets.
ACE_HANDLE | accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
| BSD-style <accept> (no QoS). More...
ACE_HANDLE | accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen, const ACE_Accept_QoS_Params &qos_params)
int | connect (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
| BSD-style <connect> (no QoS). More...
int | connect (ACE_HANDLE handle, const sockaddr *addr, int addrlen, const ACE_QoS_Params &qos_params)
int | bind (ACE_HANDLE s, struct sockaddr *name, int namelen)
int | closesocket (ACE_HANDLE s)
hostent * | gethostbyaddr (const char *addr, int length, int type)
hostent * | gethostbyname (const char *name)
hostent * | getipnodebyname (const char *name, int family, int flags=0)
hostent * | getipnodebyaddr (const void *src, size_t len, int family)
hostent * | gethostbyaddr_r (const char *addr, int length, int type, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
hostent * | gethostbyname_r (const char *name, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
int | getpeername (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
protoent * | getprotobyname (const char *name)
protoent * | getprotobyname_r (const char *name, struct protoent *result, ACE_PROTOENT_DATA buffer)
protoent * | getprotobynumber (int proto)
protoent * | getprotobynumber_r (int proto, struct protoent *result, ACE_PROTOENT_DATA buffer)
servent * | getservbyname (const char *svc, const char *proto)
servent * | getservbyname_r (const char *svc, const char *proto, struct servent *result, ACE_SERVENT_DATA buf)
int | getsockname (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
int | getsockopt (ACE_HANDLE handle, int level, int optname, char *optval, int *optlen)
unsigned long | inet_addr (const char *name)
char * | inet_ntoa (const struct in_addr addr)
int | inet_aton (const char *strptr, 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 | enum_protocols (int *protocols, ACE_Protocol_Info *protocol_buffer, u_long *buffer_length)
| Retrieve information about available transport protocols installed on the local machine. More...
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. More...
int | listen (ACE_HANDLE handle, int backlog)
int | recv (ACE_HANDLE handle, char *buf, int len, int flags=0)
int | recvfrom (ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen)
int | 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)
int | send (ACE_HANDLE handle, const char *buf, int len, int flags=0)
int | sendto (ACE_HANDLE handle, const char *buf, int len, int flags, const struct sockaddr *addr, int addrlen)
int | 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)
int | setsockopt (ACE_HANDLE handle, int level, int optname, const char *optval, int optlen)
| Manipulate the options associated with a socket. More...
int | shutdown (ACE_HANDLE handle, int how)
ACE_HANDLE | socket (int protocol_family, int type, int proto)
| Create a BSD-style socket (no QoS). More...
ACE_HANDLE | socket (int protocol_family, int type, int proto, ACE_Protocol_Info *protocolinfo, ACE_SOCK_GROUP g, u_long flags)
| Create a QoS-enabled socket. If the OS platform doesn't support QoS-enabled <socket> then the BSD-style <socket> is called. More...
int | socketpair (int domain, int type, int protocol, ACE_HANDLE sv[2])
int | socket_init (int version_high=1, int version_low=1)
| Initialize WinSock before first use (e.g., when a DLL is first loaded or the first use of a socket() call. More...
int | socket_fini (void)
| Finalize WinSock after last use (e.g., when a DLL is unloaded). More...
A set of wrappers for password routines.
void | setpwent (void)
void | endpwent (void)
passwd * | getpwent (void)
passwd * | getpwnam (const char *user)
passwd * | getpwnam_r (const char *name, struct passwd *pwent, char *buffer, int buflen)
A set of wrappers for regular expressions.
char * | compile (const char *instring, char *expbuf, char *endbuf)
int | step (const char *str, char *expbuf)
## Static Public Attributes
int | socket_initialized_
| Keeps track of whether we've already initialized WinSock... More...
## Private Methods
| ACE_CLASS_IS_NAMESPACE (ACE_OS)
## Static Private Methods
ACE_EXIT_HOOK | set_exit_hook (ACE_EXIT_HOOK hook)
| For use by ACE_Object_Manager only, to register its exit hook.. More...
void | fopen_mode_to_open_mode_converter (ACE_TCHAR x, int &hmode)
| Translate fopen's mode char to open's mode. This helper function is here to avoid maintaining several pieces of identical code. More...
int | cond_timedwait_i (ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *)
u_int | alarm_i (u_int secs)
u_int | ualarm_i (u_int usecs, u_int interval=0)
u_int | ualarm_i (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)
int | sleep_i (u_int seconds)
int | sleep_i (const ACE_Time_Value &tv)
int | nanosleep_i (const struct timespec *requested, struct timespec *remaining=0)
int | select_i (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value *tv=0)
int | select_i (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv)
int | poll_i (struct pollfd *pollfds, u_long len, const ACE_Time_Value *tv=0)
int | poll_i (struct pollfd *pollfds, u_long len, const ACE_Time_Value &tv)
int | sema_wait_i (ACE_sema_t *s)
int | sema_wait_i (ACE_sema_t *s, ACE_Time_Value &tv)
int | sigtimedwait_i (const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout)
ACE_Time_Value | gettimeofday_i (void)
## Static Private Attributes
ACE_EXIT_HOOK | exit_hook_ = 0
| Function that is called by <ACE_OS::exit>, if non-null. More...
OSVERSIONINFO | win32_versioninfo_
HINSTANCE | win32_resource_module_
## Friends
class | ACE_Timeout_Manager
class | ACE_OS_Object_Manager
| Allow the ACE_OS_Object_Manager to call set_exit_hook. More...

## Detailed Description

This class 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 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 <www.cs.wustl.edu/~schmidt/ACE_wrappers/etc/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.

## Member Typedef Documentation

typedef ACE_UINT16 ACE_OS::WChar

## Member Enumeration Documentation

enum ACE_OS::ACE_HRTimer_Op

  | Enumeration values:
  ACE_HRTIMER_START |
  ACE_HRTIMER_INCR |
  ACE_HRTIMER_STOP |
  ACE_HRTIMER_GETTIME |

## Member Function Documentation

ACE_INLINE void ACE_OS::_exit | ( | int | status = 0 | ) | `[static]`

ACE_INLINE void ACE_OS::abort | ( | void |  | ) | `[static]`

ACE_HANDLE ACE_OS::accept | ( | ACE_HANDLE | handle,
|  | struct sockaddr * | addr,
|  | int * | addrlen,
|  | const ACE_Accept_QoS_Params & | qos_params
| ) | `[static]`

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

ACE_INLINE ACE_HANDLE ACE_OS::accept | ( | ACE_HANDLE | handle,
|  | struct sockaddr * | addr,
|  | int * | addrlen
| ) | `[static]`

| BSD-style <accept> (no QoS).

int ACE_OS::access | ( | const wchar_t * | path,
|  | int | amode
| ) | `[static]`

ACE_INLINE int ACE_OS::access | ( | const char * | path,
|  | int | amode
| ) | `[static]`

ACE_OS::ACE_CLASS_IS_NAMESPACE | ( | ACE_OS |  | ) | `[private]`

void ACE_OS::adjust_flock_params | ( | ACE_OS::ace_flock_t * | lock,
|  | short | whence,
|  | off_t & | start,
|  | off_t & | len
| ) | `[static]`

ACE_INLINE u_int ACE_OS::alarm | ( | u_int | secs | ) | `[static]`

u_int ACE_OS::alarm_i | ( | u_int | secs | ) | `[static, private]`

ACE_INLINE int ACE_OS::allocation_granularity | ( | void |  | ) | `[static]`

int ACE_OS::argv_to_string | ( | ACE_TCHAR ** | argv,
|  | ACE_TCHAR *& | buf,
|  | int | substitute_env_args = 1
| ) | `[static]`

ACE_INLINE char * ACE_OS::asctime | ( | const struct tm * | t | ) | `[static]`

ACE_INLINE char * ACE_OS::asctime_r | ( | const struct tm * | t,
|  | char * | buf,
|  | int | buflen
| ) | `[static]`

ACE_INLINE int ACE_OS::atexit | ( | ACE_EXIT_HOOK | func | ) | `[static]`

int ACE_OS::atoi | ( | const wchar_t * | s | ) | `[static]`

ACE_INLINE int ACE_OS::atoi | ( | const char * | s | ) | `[static]`

ACE_INLINE int ACE_OS::bind | ( | ACE_HANDLE | handle,
|  | struct sockaddr * | addr,
|  | int | addrlen
| ) | `[static]`

ACE_INLINE void * ACE_OS::bsearch | ( | const void * | key,
|  | const void * | base,
|  | size_t | nel,
|  | size_t | size,
|  | ACE_COMPARE_FUNC | compar
| ) | `[static]`

ACE_INLINE double ACE_OS::ceil | ( | double | x | ) | `[static]`

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

int ACE_OS::chdir | ( | const wchar_t * | path | ) | `[static]`

ACE_INLINE int ACE_OS::chdir | ( | const char * | path | ) | `[static]`

void ACE_OS::cleanup_tss | ( | const u_int | main_thread | ) | `[static]`

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

ACE_INLINE int ACE_OS::clock_gettime | ( | clockid_t | clockid,
|  | struct timespec * | ts
| ) | `[static]`

ACE_INLINE int ACE_OS::close | ( | ACE_HANDLE | handle | ) | `[static]`

ACE_INLINE int ACE_OS::closesocket | ( | ACE_HANDLE | handle | ) | `[static]`

ACE_INLINE char * ACE_OS::compile | ( | const char * | instring,
|  | char * | expbuf,
|  | char * | endbuf
| ) | `[static]`

ACE_INLINE int ACE_OS::cond_broadcast | ( | ACE_cond_t * | cv | ) | `[static]`

ACE_INLINE int ACE_OS::cond_destroy | ( | ACE_cond_t * | cv | ) | `[static]`

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

int ACE_OS::cond_init | ( | ACE_cond_t * | cv,
|  | short | type,
|  | const wchar_t * | name,
|  | void * | arg = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::cond_init | ( | ACE_cond_t * | cv,
|  | ACE_condattr_t & | attributes,
|  | const char * | name = 0,
|  | void * | arg = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::cond_init | ( | ACE_cond_t * | cv,
|  | short | type = ACE_DEFAULT_SYNCH_TYPE,
|  | const char * | name = 0,
|  | void * | arg = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::cond_signal | ( | ACE_cond_t * | cv | ) | `[static]`

ACE_INLINE int ACE_OS::cond_timedwait | ( | ACE_cond_t * | cv,
|  | ACE_mutex_t * | external_mutex,
|  | ACE_Time_Value * | timeout
| ) | `[static]`

int ACE_OS::cond_timedwait_i | ( | ACE_cond_t * | cv,
|  | ACE_mutex_t * | m,
|  | ACE_Time_Value * |
| ) | `[static, private]`

ACE_INLINE int ACE_OS::cond_wait | ( | ACE_cond_t * | cv,
|  | ACE_mutex_t * | external_mutex
| ) | `[static]`

ACE_INLINE int ACE_OS::condattr_destroy | ( | ACE_condattr_t & | attributes | ) | `[static]`

ACE_INLINE int ACE_OS::condattr_init | ( | ACE_condattr_t & | attributes,
|  | int | type = ACE_DEFAULT_SYNCH_TYPE
| ) | `[static]`

int ACE_OS::connect | ( | ACE_HANDLE | handle,
|  | const sockaddr * | addr,
|  | int | addrlen,
|  | const ACE_QoS_Params & | qos_params
| ) | `[static]`

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

ACE_INLINE int ACE_OS::connect | ( | ACE_HANDLE | handle,
|  | struct sockaddr * | addr,
|  | int | addrlen
| ) | `[static]`

| BSD-style <connect> (no QoS).

ACE_INLINE ACE_HANDLE ACE_OS::creat | ( | const ACE_TCHAR * | filename,
|  | mode_t | mode
| ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::ctime | ( | const time_t * | t | ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::ctime_r | ( | const time_t * | t,
|  | ACE_TCHAR * | buf,
|  | int | buflen
| ) | `[static]`

wchar_t* ACE_OS::cuserid | ( | wchar_t * | user,
|  | size_t | maxlen = ACE_MAX_USERID
| ) | `[static]`

ACE_INLINE char * ACE_OS::cuserid | ( | char * | user,
|  | size_t | maxlen = ACE_MAX_USERID
| ) | `[static]`

LPSECURITY_ATTRIBUTES ACE_OS::default_win32_security_attributes | ( | LPSECURITY_ATTRIBUTES |  | ) | `[static]`

ACE_INLINE double ACE_OS::difftime | ( | time_t | t1,
|  | time_t | t0
| ) | `[static]`

ACE_INLINE int ACE_OS::dlclose | ( | ACE_SHLIB_HANDLE | handle | ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::dlerror | ( | void |  | ) | `[static]`

ACE_INLINE ACE_SHLIB_HANDLE ACE_OS::dlopen | ( | const ACE_TCHAR * | fname,
|  | int | mode = ACE_DEFAULT_SHLIB_MODE
| ) | `[static]`

ACE_INLINE void * ACE_OS::dlsym | ( | ACE_SHLIB_HANDLE | handle,
|  | const ACE_TCHAR * | sname
| ) | `[static]`

ACE_INLINE ACE_HANDLE ACE_OS::dup | ( | ACE_HANDLE | handle | ) | `[static]`

ACE_INLINE int ACE_OS::dup2 | ( | ACE_HANDLE | oldhandle,
|  | ACE_HANDLE | newhandle
| ) | `[static]`

ACE_INLINE void ACE_OS::endpwent | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::enum_protocols | ( | int * | protocols,
|  | ACE_Protocol_Info * | protocol_buffer,
|  | u_long * | buffer_length
| ) | `[static]`

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

ACE_INLINE int ACE_OS::event_destroy | ( | ACE_event_t * | event | ) | `[static]`

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
| ) | `[static]`

ACE_INLINE 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
| ) | `[static]`

ACE_INLINE int ACE_OS::event_pulse | ( | ACE_event_t * | event | ) | `[static]`

ACE_INLINE int ACE_OS::event_reset | ( | ACE_event_t * | event | ) | `[static]`

ACE_INLINE int ACE_OS::event_signal | ( | ACE_event_t * | event | ) | `[static]`

ACE_INLINE int ACE_OS::event_timedwait | ( | ACE_event_t * | event,
|  | ACE_Time_Value * | timeout,
|  | int | use_absolute_time = 1
| ) | `[static]`

ACE_INLINE int ACE_OS::event_wait | ( | ACE_event_t * | event | ) | `[static]`

int ACE_OS::execl | ( | const char * | path,
|  | const char * | arg0,
|  | ... |
| ) | `[static]`

int ACE_OS::execle | ( | const char * | path,
|  | const char * | arg0,
|  | ... |
| ) | `[static]`

int ACE_OS::execlp | ( | const char * | file,
|  | const char * | arg0,
|  | ... |
| ) | `[static]`

ACE_INLINE int ACE_OS::execv | ( | const char * | path,
|  | char *const | argv[]
| ) | `[static]`

ACE_INLINE int ACE_OS::execve | ( | const char * | path,
|  | char *const | argv[],
|  | char *const | envp[]
| ) | `[static]`

ACE_INLINE int ACE_OS::execvp | ( | const char * | file,
|  | char *const | argv[]
| ) | `[static]`

void ACE_OS::exit | ( | int | status = 0 | ) | `[static]`

ACE_INLINE int ACE_OS::fattach | ( | int | handle,
|  | const char * | path
| ) | `[static]`

ACE_INLINE int ACE_OS::fclose | ( | FILE * | fp | ) | `[static]`

ACE_INLINE int ACE_OS::fcntl | ( | ACE_HANDLE | handle,
|  | int | cmd,
|  | long | arg = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::fdetach | ( | const char * | file | ) | `[static]`

ACE_INLINE FILE * ACE_OS::fdopen | ( | ACE_HANDLE | handle,
|  | const ACE_TCHAR * | mode
| ) | `[static]`

ACE_INLINE int ACE_OS::fflush | ( | FILE * | fp | ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::fgets | ( | ACE_TCHAR * | buf,
|  | int | size,
|  | FILE * | fp
| ) | `[static]`

ACE_INLINE long ACE_OS::filesize | ( | const ACE_TCHAR * | filename | ) | `[static]`

ACE_INLINE long ACE_OS::filesize | ( | ACE_HANDLE | handle | ) | `[static]`

ACE_INLINE int ACE_OS::flock_destroy | ( | ACE_OS::ace_flock_t * | lock,
|  | int | unlink_file = 1
| ) | `[static]`

ACE_INLINE int ACE_OS::flock_init | ( | ACE_OS::ace_flock_t * | lock,
|  | int | flags = 0,
|  | const ACE_TCHAR * | name = 0,
|  | mode_t | perms = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::flock_rdlock | ( | ACE_OS::ace_flock_t * | lock,
|  | short | whence = 0,
|  | off_t | start = 0,
|  | off_t | len = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::flock_tryrdlock | ( | ACE_OS::ace_flock_t * | lock,
|  | short | whence = 0,
|  | off_t | start = 0,
|  | off_t | len = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::flock_trywrlock | ( | ACE_OS::ace_flock_t * | lock,
|  | short | whence = 0,
|  | off_t | start = 0,
|  | off_t | len = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::flock_unlock | ( | ACE_OS::ace_flock_t * | lock,
|  | short | whence = 0,
|  | off_t | start = 0,
|  | off_t | len = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::flock_wrlock | ( | ACE_OS::ace_flock_t * | lock,
|  | short | whence = 0,
|  | off_t | start = 0,
|  | off_t | len = 0
| ) | `[static]`

ACE_INLINE double ACE_OS::floor | ( | double | x | ) | `[static]`

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

ACE_INLINE FILE * ACE_OS::fopen | ( | const ACE_TCHAR * | filename,
|  | const ACE_TCHAR * | mode
| ) | `[static]`

void ACE_OS::fopen_mode_to_open_mode_converter | ( | ACE_TCHAR | x,
|  | int & | hmode
| ) | `[static, private]`

| Translate fopen's mode char to open's mode. This helper function is here to avoid maintaining several pieces of identical code.

pid_t ACE_OS::fork | ( | const ACE_TCHAR * | program_name | ) | `[static]`

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

ACE_INLINE pid_t ACE_OS::fork | ( | void |  | ) | `[static]`

pid_t ACE_OS::fork_exec | ( | ACE_TCHAR * | argv[] | ) | `[static]`

int ACE_OS::fprintf | ( | FILE * | fp,
|  | const wchar_t * | format,
|  | ... |
| ) | `[static]`

int ACE_OS::fprintf | ( | FILE * | fp,
|  | const char * | format,
|  | ... |
| ) | `[static]`

ACE_INLINE int ACE_OS::fputs | ( | const ACE_TCHAR * | s,
|  | FILE * | stream
| ) | `[static]`

ACE_INLINE size_t ACE_OS::fread | ( | void * | ptr,
|  | size_t | size,
|  | size_t | nelems,
|  | FILE * | fp
| ) | `[static]`

ACE_INLINE FILE * ACE_OS::freopen | ( | const ACE_TCHAR * | filename,
|  | const ACE_TCHAR * | mode,
|  | FILE * | stream
| ) | `[static]`

ACE_INLINE int ACE_OS::fseek | ( | FILE * | fp,
|  | long | offset,
|  | int | whence
| ) | `[static]`

ACE_INLINE int ACE_OS::fstat | ( | ACE_HANDLE | handle,
|  | ACE_stat * | stp
| ) | `[static]`

ACE_INLINE int ACE_OS::fsync | ( | ACE_HANDLE | handle | ) | `[static]`

ACE_INLINE int ACE_OS::ftruncate | ( | ACE_HANDLE | handle,
|  | off_t | offset
| ) | `[static]`

ACE_INLINE size_t ACE_OS::fwrite | ( | const void * | ptr,
|  | size_t | size,
|  | size_t | nitems,
|  | FILE * | fp
| ) | `[static]`

HINSTANCE ACE_OS::get_win32_resource_module | ( | void |  | ) | `[static]`

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

const OSVERSIONINFO& ACE_OS::get_win32_versioninfo | ( | void |  | ) | `[static]`

| Return the win32 OSVERSIONINFO structure.

ACE_INLINE ACE_TCHAR * ACE_OS::getcwd | ( | ACE_TCHAR * | buf,
|  | size_t | size
| ) | `[static]`

wchar_t* ACE_OS::getenv | ( | const wchar_t * | symbol | ) | `[static]`

ACE_INLINE char * ACE_OS::getenv | ( | const char * | symbol | ) | `[static]`

ACE_TCHAR * ACE_OS::getenvstrings | ( | void |  | ) | `[static]`

ACE_INLINE gid_t ACE_OS::getgid | ( | void |  | ) | `[static]`

ACE_INLINE struct hostent * ACE_OS::gethostbyaddr | ( | const char * | addr,
|  | int | length,
|  | int | type
| ) | `[static]`

struct hostent* ACE_OS::gethostbyaddr_r | ( | const char * | addr,
|  | int | length,
|  | int | type,
|  | struct hostent * | result,
|  | ACE_HOSTENT_DATA | buffer,
|  | int * | h_errnop
| ) | `[static]`

ACE_INLINE struct hostent * ACE_OS::gethostbyname | ( | const char * | name | ) | `[static]`

struct hostent* ACE_OS::gethostbyname_r | ( | const char * | name,
|  | struct hostent * | result,
|  | ACE_HOSTENT_DATA | buffer,
|  | int * | h_errnop
| ) | `[static]`

ACE_INLINE ACE_hrtime_t ACE_OS::gethrtime | ( | const ACE_HRTimer_Op | op = ACE_HRTIMER_GETTIME | ) | `[static]`

ACE_INLINE struct hostent * ACE_OS::getipnodebyaddr | ( | const void * | src,
|  | size_t | len,
|  | int | family
| ) | `[static]`

ACE_INLINE struct hostent * ACE_OS::getipnodebyname | ( | const char * | name,
|  | int | family,
|  | int | flags = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::getmsg | ( | ACE_HANDLE | handle,
|  | struct strbuf * | ctl,
|  | struct strbuf * | data,
|  | int * | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::getopt | ( | int | argc,
|  | char *const * | argv,
|  | const char * | optstring
| ) | `[static]`

ACE_INLINE int ACE_OS::getpagesize | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::getpeername | ( | ACE_HANDLE | handle,
|  | struct sockaddr * | addr,
|  | int * | addrlen
| ) | `[static]`

ACE_INLINE pid_t ACE_OS::getpgid | ( | pid_t | pid | ) | `[static]`

ACE_INLINE pid_t ACE_OS::getpid | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::getpmsg | ( | ACE_HANDLE | handle,
|  | struct strbuf * | ctl,
|  | struct strbuf * | data,
|  | int * | band,
|  | int * | flags
| ) | `[static]`

ACE_INLINE pid_t ACE_OS::getppid | ( | void |  | ) | `[static]`

ACE_INLINE struct protoent * ACE_OS::getprotobyname | ( | const char * | name | ) | `[static]`

ACE_INLINE struct protoent * ACE_OS::getprotobyname_r | ( | const char * | name,
|  | struct protoent * | result,
|  | ACE_PROTOENT_DATA | buffer
| ) | `[static]`

ACE_INLINE struct protoent * ACE_OS::getprotobynumber | ( | int | proto | ) | `[static]`

ACE_INLINE struct protoent * ACE_OS::getprotobynumber_r | ( | int | proto,
|  | struct protoent * | result,
|  | ACE_PROTOENT_DATA | buffer
| ) | `[static]`

ACE_INLINE struct passwd * ACE_OS::getpwent | ( | void |  | ) | `[static]`

ACE_INLINE struct passwd * ACE_OS::getpwnam | ( | const char * | name | ) | `[static]`

ACE_INLINE struct passwd * ACE_OS::getpwnam_r | ( | const char * | name,
|  | struct passwd * | pwent,
|  | char * | buffer,
|  | int | buflen
| ) | `[static]`

ACE_INLINE int ACE_OS::getrlimit | ( | int | resource,
|  | struct rlimit * | rl
| ) | `[static]`

ACE_INLINE int ACE_OS::getrusage | ( | int | who,
|  | struct rusage * | ru
| ) | `[static]`

char * ACE_OS::gets | ( | char * | str,
|  | int | n = 0
| ) | `[static]`

ACE_INLINE struct servent * ACE_OS::getservbyname | ( | const char * | svc,
|  | const char * | proto
| ) | `[static]`

ACE_INLINE struct servent * ACE_OS::getservbyname_r | ( | const char * | svc,
|  | const char * | proto,
|  | struct servent * | result,
|  | ACE_SERVENT_DATA | buf
| ) | `[static]`

ACE_INLINE int ACE_OS::getsockname | ( | ACE_HANDLE | handle,
|  | struct sockaddr * | addr,
|  | int * | addrlen
| ) | `[static]`

ACE_INLINE int ACE_OS::getsockopt | ( | ACE_HANDLE | handle,
|  | int | level,
|  | int | optname,
|  | char * | optval,
|  | int * | optlen
| ) | `[static]`

ACE_INLINE ACE_Time_Value ACE_OS::gettimeofday | ( | void |  | ) | `[static]`

ACE_Time_Value ACE_OS::gettimeofday_i | ( | void |  | ) | `[static, private]`

ACE_INLINE uid_t ACE_OS::getuid | ( | void |  | ) | `[static]`

ACE_INLINE struct tm * ACE_OS::gmtime | ( | const time_t * | t | ) | `[static]`

ACE_INLINE struct tm * ACE_OS::gmtime_r | ( | const time_t * | t,
|  | struct tm * | res
| ) | `[static]`

int ACE_OS::hostname | ( | wchar_t * | name,
|  | size_t | maxnamelen
| ) | `[static]`

int ACE_OS::hostname | ( | char * | name,
|  | size_t | maxnamelen
| ) | `[static]`

ACE_INLINE unsigned long ACE_OS::inet_addr | ( | const char * | name | ) | `[static]`

int ACE_OS::inet_aton | ( | const char * | host_name,
|  | struct in_addr * | addr
| ) | `[static]`

ACE_INLINE char * ACE_OS::inet_ntoa | ( | const struct in_addr | addr | ) | `[static]`

ACE_INLINE const char * ACE_OS::inet_ntop | ( | int | family,
|  | const void * | addrptr,
|  | char * | strptr,
|  | size_t | len
| ) | `[static]`

ACE_INLINE int ACE_OS::inet_pton | ( | int | family,
|  | const char * | strptr,
|  | void * | addrptr
| ) | `[static]`

int ACE_OS::ioctl | ( | ACE_HANDLE | socket,
|  | u_long | io_control_code,
|  | ACE_QoS & | ace_qos,
|  | u_long * | bytes_returned,
|  | void * | buffer_p = 0,
|  | u_long | buffer = 0,
|  | ACE_OVERLAPPED * | overlapped = 0,
|  | ACE_OVERLAPPED_COMPLETION_FUNC | func = 0
| ) | `[static]`

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

int ACE_OS::ioctl | ( | ACE_HANDLE | socket,
|  | u_long | io_control_code,
|  | void * | in_buffer_p,
|  | u_long | in_buffer,
|  | void * | out_buffer_p,
|  | u_long | out_buffer,
|  | u_long * | bytes_returned,
|  | ACE_OVERLAPPED * | overlapped,
|  | ACE_OVERLAPPED_COMPLETION_FUNC | func
| ) | `[static]`

| QoS-enabled <ioctl>.

ACE_INLINE int ACE_OS::ioctl | ( | ACE_HANDLE | handle,
|  | int | cmd,
|  | void * | val = 0
| ) | `[static]`

| UNIX-style <ioctl>.

ACE_INLINE int ACE_OS::isastream | ( | ACE_HANDLE | handle | ) | `[static]`

int ACE_OS::isatty | ( | ACE_HANDLE | handle | ) | `[static]`

ACE_INLINE int ACE_OS::isatty | ( | int | handle | ) | `[static]`

ACE_HANDLE ACE_OS::join_leaf | ( | ACE_HANDLE | socket,
|  | const sockaddr * | name,
|  | int | namelen,
|  | const ACE_QoS_Params & | qos_params
| ) | `[static]`

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

ACE_INLINE int ACE_OS::kill | ( | pid_t | pid,
|  | int | signum
| ) | `[static]`

ACE_INLINE void ACE_OS::last_error | ( | int | error | ) | `[static]`

ACE_INLINE int ACE_OS::last_error | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::listen | ( | ACE_HANDLE | handle,
|  | int | backlog
| ) | `[static]`

ACE_INLINE struct tm * ACE_OS::localtime | ( | const time_t * | t | ) | `[static]`

struct tm * ACE_OS::localtime_r | ( | const time_t * | t,
|  | struct tm * | res
| ) | `[static]`

ACE_INLINE off_t ACE_OS::lseek | ( | ACE_HANDLE | handle,
|  | off_t | offset,
|  | int | whence
| ) | `[static]`

ACE_INLINE int ACE_OS::lstat | ( | const char * | file,
|  | ACE_stat * | stp
| ) | `[static]`

int ACE_OS::lwp_getparams | ( | ACE_Sched_Params & | sched_params | ) | `[static]`

int ACE_OS::lwp_setparams | ( | const ACE_Sched_Params & | sched_params | ) | `[static]`

ACE_INLINE int ACE_OS::madvise | ( | caddr_t | addr,
|  | size_t | len,
|  | int | advice
| ) | `[static]`

ACE_INLINE int ACE_OS::mkdir | ( | const ACE_TCHAR * | path,
|  | mode_t | mode = ACE_DEFAULT_DIR_PERMS
| ) | `[static]`

ACE_INLINE int ACE_OS::mkfifo | ( | const ACE_TCHAR * | file,
|  | mode_t | mode = ACE_DEFAULT_FILE_PERMS
| ) | `[static]`

ACE_INLINE ACE_HANDLE ACE_OS::mkstemp | ( | ACE_TCHAR * | s | ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::mktemp | ( | ACE_TCHAR * | s | ) | `[static]`

time_t ACE_OS::mktime | ( | struct tm * | t | ) | `[static]`

ACE_INLINE void * ACE_OS::mmap | ( | void * | addr,
|  | size_t | len,
|  | int | prot,
|  | int | flags,
|  | ACE_HANDLE | file_handle,
|  | off_t | off = 0,
|  | ACE_HANDLE * | file_mapping = 0,
|  | LPSECURITY_ATTRIBUTES | sa = 0,
|  | const ACE_TCHAR * | file_mapping_name = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::mprotect | ( | void * | addr,
|  | size_t | len,
|  | int | prot
| ) | `[static]`

ACE_INLINE int ACE_OS::msgctl | ( | int | msqid,
|  | int | cmd,
|  | struct msqid_ds * | val
| ) | `[static]`

ACE_INLINE int ACE_OS::msgget | ( | key_t | key,
|  | int | msgflg
| ) | `[static]`

ACE_INLINE int ACE_OS::msgrcv | ( | int | int_id,
|  | void * | buf,
|  | size_t | len,
|  | long | type,
|  | int | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::msgsnd | ( | int | int_id,
|  | const void * | buf,
|  | size_t | len,
|  | int | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::msync | ( | void * | addr,
|  | size_t | len,
|  | int | sync
| ) | `[static]`

ACE_INLINE int ACE_OS::munmap | ( | void * | addr,
|  | size_t | len
| ) | `[static]`

ACE_INLINE int ACE_OS::mutex_destroy | ( | ACE_mutex_t * | m | ) | `[static]`

int ACE_OS::mutex_init | ( | ACE_mutex_t * | m,
|  | int | type,
|  | const wchar_t * | name,
|  | ACE_mutexattr_t * | arg = 0,
|  | LPSECURITY_ATTRIBUTES | sa = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::mutex_init | ( | ACE_mutex_t * | m,
|  | int | type = ACE_DEFAULT_SYNCH_TYPE,
|  | const char * | name = 0,
|  | ACE_mutexattr_t * | attributes = 0,
|  | LPSECURITY_ATTRIBUTES | sa = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::mutex_lock | ( | ACE_mutex_t * | m,
|  | const ACE_Time_Value * | timeout
| ) | `[static]`

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

ACE_INLINE int ACE_OS::mutex_lock | ( | ACE_mutex_t * | m,
|  | const ACE_Time_Value & | timeout
| ) | `[static]`

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

ACE_INLINE int ACE_OS::mutex_lock | ( | ACE_mutex_t * | m,
|  | int & | abandoned
| ) | `[static]`

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

ACE_INLINE int ACE_OS::mutex_lock | ( | ACE_mutex_t * | m | ) | `[static]`

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

void ACE_OS::mutex_lock_cleanup | ( | void * | mutex | ) | `[static]`

| Handle asynchronous thread cancellation cleanup.

ACE_INLINE int ACE_OS::mutex_trylock | ( | ACE_mutex_t * | m,
|  | int & | abandoned
| ) | `[static]`

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

ACE_INLINE int ACE_OS::mutex_trylock | ( | ACE_mutex_t * | m | ) | `[static]`

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

ACE_INLINE int ACE_OS::mutex_unlock | ( | ACE_mutex_t * | m | ) | `[static]`

ACE_INLINE int ACE_OS::nanosleep | ( | const struct timespec * | requested,
|  | struct timespec * | remaining = 0
| ) | `[static]`

int ACE_OS::nanosleep_i | ( | const struct timespec * | requested,
|  | struct timespec * | remaining = 0
| ) | `[static, private]`

ACE_HANDLE ACE_OS::open | ( | const wchar_t * | filename,
|  | int | mode,
|  | int | perms = ACE_DEFAULT_OPEN_PERMS,
|  | LPSECURITY_ATTRIBUTES | sa = 0
| ) | `[static]`

ACE_HANDLE ACE_OS::open | ( | const char * | filename,
|  | int | mode,
|  | int | perms = ACE_DEFAULT_OPEN_PERMS,
|  | LPSECURITY_ATTRIBUTES | sa = 0
| ) | `[static]`

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

ACE_INLINE void ACE_OS::perror | ( | const ACE_TCHAR * | s | ) | `[static]`

ACE_INLINE int ACE_OS::pipe | ( | ACE_HANDLE | fds[] | ) | `[static]`

ACE_INLINE int ACE_OS::poll | ( | struct pollfd * | pollfds,
|  | u_long | len,
|  | const ACE_Time_Value & | timeout
| ) | `[static]`

ACE_INLINE int ACE_OS::poll | ( | struct pollfd * | pollfds,
|  | u_long | len,
|  | const ACE_Time_Value * | timeout = 0
| ) | `[static]`

int ACE_OS::poll_i | ( | struct pollfd * | pollfds,
|  | u_long | len,
|  | const ACE_Time_Value & | tv
| ) | `[static, private]`

int ACE_OS::poll_i | ( | struct pollfd * | pollfds,
|  | u_long | len,
|  | const ACE_Time_Value * | tv = 0
| ) | `[static, private]`

ssize_t ACE_OS::pread | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | nbytes,
|  | off_t | offset
| ) | `[static]`

int ACE_OS::printf | ( | const char * | format,
|  | ... |
| ) | `[static]`

ACE_INLINE int ACE_OS::priority_control | ( | ACE_idtype_t | idtype,
|  | ACE_id_t | id,
|  | int | cmd,
|  | void * | arg
| ) | `[static]`

| Low-level interface to <priocntl>(2). Can't call the following priocntl, because that's a macro on Solaris.

ACE_INLINE int ACE_OS::pthread_sigmask | ( | int | how,
|  | const sigset_t * | nsp,
|  | sigset_t * | osp
| ) | `[static]`

ACE_INLINE int ACE_OS::putenv | ( | const ACE_TCHAR * | string | ) | `[static]`

ACE_INLINE int ACE_OS::putmsg | ( | ACE_HANDLE | handle,
|  | const struct strbuf * | ctl,
|  | const struct strbuf * | data,
|  | int | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::putpmsg | ( | ACE_HANDLE | handle,
|  | const struct strbuf * | ctl,
|  | const struct strbuf * | data,
|  | int | band,
|  | int | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::puts | ( | const ACE_TCHAR * | s | ) | `[static]`

ssize_t ACE_OS::pwrite | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | nbytes,
|  | off_t | offset
| ) | `[static]`

ACE_INLINE void ACE_OS::qsort | ( | void * | base,
|  | size_t | nel,
|  | size_t | width,
|  | ACE_COMPARE_FUNC | compar
| ) | `[static]`

ACE_INLINE int ACE_OS::rand | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::rand_r | ( | ACE_RANDR_TYPE & | seed | ) | `[static]`

ACE_INLINE ssize_t ACE_OS::read | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | ACE_OVERLAPPED * | overlapped
| ) | `[static]`

ACE_INLINE ssize_t ACE_OS::read | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len
| ) | `[static]`

ssize_t ACE_OS::read_n | ( | ACE_HANDLE | handle,
|  | void * | buf,
|  | size_t | len,
|  | size_t * | bt = 0
| ) | `[static]`

| 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 transmitted will be returned to the caller through <bytes_transferred>.

ACE_INLINE int ACE_OS::readlink | ( | const char * | path,
|  | char * | buf,
|  | size_t | bufsiz
| ) | `[static]`

ACE_INLINE ssize_t ACE_OS::readv | ( | ACE_HANDLE | handle,
|  | iovec * | iov,
|  | int | iovlen
| ) | `[static]`

ACE_INLINE int ACE_OS::recursive_mutex_destroy | ( | ACE_recursive_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE 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
| ) | `[static]`

ACE_INLINE int ACE_OS::recursive_mutex_lock | ( | ACE_recursive_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE int ACE_OS::recursive_mutex_trylock | ( | ACE_recursive_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE int ACE_OS::recursive_mutex_unlock | ( | ACE_recursive_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE int ACE_OS::recv | ( | ACE_HANDLE | handle,
|  | char * | buf,
|  | int | len,
|  | int | flags = 0
| ) | `[static]`

ACE_INLINE int 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
| ) | `[static]`

ACE_INLINE int ACE_OS::recvfrom | ( | ACE_HANDLE | handle,
|  | char * | buf,
|  | int | len,
|  | int | flags,
|  | struct sockaddr * | addr,
|  | int * | addrlen
| ) | `[static]`

ACE_INLINE int ACE_OS::recvmsg | ( | ACE_HANDLE | handle,
|  | struct msghdr * | msg,
|  | int | flags
| ) | `[static]`

ACE_INLINE ssize_t ACE_OS::recvv | ( | ACE_HANDLE | handle,
|  | iovec * | buffers,
|  | int | n
| ) | `[static]`

ACE_INLINE int ACE_OS::rename | ( | const ACE_TCHAR * | old_name,
|  | const ACE_TCHAR * | new_name,
|  | int | flags = -1
| ) | `[static]`

ACE_INLINE void ACE_OS::rewind | ( | FILE * | fp | ) | `[static]`

ACE_INLINE int ACE_OS::rw_rdlock | ( | ACE_rwlock_t * | rw | ) | `[static]`

ACE_INLINE int ACE_OS::rw_tryrdlock | ( | ACE_rwlock_t * | rw | ) | `[static]`

ACE_INLINE int ACE_OS::rw_trywrlock | ( | ACE_rwlock_t * | rw | ) | `[static]`

ACE_INLINE int ACE_OS::rw_trywrlock_upgrade | ( | ACE_rwlock_t * | rw | ) | `[static]`

ACE_INLINE int ACE_OS::rw_unlock | ( | ACE_rwlock_t * | rw | ) | `[static]`

ACE_INLINE int ACE_OS::rw_wrlock | ( | ACE_rwlock_t * | rw | ) | `[static]`

ACE_INLINE int ACE_OS::rwlock_destroy | ( | ACE_rwlock_t * | rw | ) | `[static]`

int ACE_OS::rwlock_init | ( | ACE_rwlock_t * | rw,
|  | int | type = ACE_DEFAULT_SYNCH_TYPE,
|  | const ACE_TCHAR * | name = 0,
|  | void * | arg = 0
| ) | `[static]`

int ACE_OS::sched_params | ( | const ACE_Sched_Params & | sched_params,
|  | ACE_id_t | id = ACE_SELF
| ) | `[static]`

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

int ACE_OS::scheduling_class | ( | const char * | class_name,
|  | ACE_id_t & | id
| ) | `[static]`

| Find the schedling class ID that corresponds to the class name.

ACE_INLINE int ACE_OS::select | ( | int | width,
|  | fd_set * | rfds,
|  | fd_set * | wfds,
|  | fd_set * | efds,
|  | const ACE_Time_Value & | timeout
| ) | `[static]`

ACE_INLINE int ACE_OS::select | ( | int | width,
|  | fd_set * | rfds,
|  | fd_set * | wfds = 0,
|  | fd_set * | efds = 0,
|  | const ACE_Time_Value * | timeout = 0
| ) | `[static]`

int ACE_OS::select_i | ( | int | width,
|  | fd_set * | rfds,
|  | fd_set * | wfds,
|  | fd_set * | efds,
|  | const ACE_Time_Value & | tv
| ) | `[static, private]`

int ACE_OS::select_i | ( | int | width,
|  | fd_set * | rfds,
|  | fd_set * | wfds,
|  | fd_set * | efds,
|  | const ACE_Time_Value * | tv = 0
| ) | `[static, private]`

ACE_INLINE int ACE_OS::sema_destroy | ( | ACE_sema_t * | s | ) | `[static]`

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
| ) | `[static]`

ACE_INLINE 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
| ) | `[static]`

ACE_INLINE int ACE_OS::sema_post | ( | ACE_sema_t * | s,
|  | size_t | release_count
| ) | `[static]`

ACE_INLINE int ACE_OS::sema_post | ( | ACE_sema_t * | s | ) | `[static]`

ACE_INLINE int ACE_OS::sema_trywait | ( | ACE_sema_t * | s | ) | `[static]`

ACE_INLINE int ACE_OS::sema_wait | ( | ACE_sema_t * | s,
|  | ACE_Time_Value * | tv
| ) | `[static]`

ACE_INLINE int ACE_OS::sema_wait | ( | ACE_sema_t * | s,
|  | ACE_Time_Value & | tv
| ) | `[static]`

ACE_INLINE int ACE_OS::sema_wait | ( | ACE_sema_t * | s | ) | `[static]`

int ACE_OS::sema_wait_i | ( | ACE_sema_t * | s,
|  | ACE_Time_Value & | tv
| ) | `[static, private]`

int ACE_OS::sema_wait_i | ( | ACE_sema_t * | s | ) | `[static, private]`

ACE_INLINE int ACE_OS::semctl | ( | int | int_id,
|  | int | semnum,
|  | int | cmd,
|  | semun | value
| ) | `[static]`

ACE_INLINE int ACE_OS::semget | ( | key_t | key,
|  | int | nsems,
|  | int | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::semop | ( | int | int_id,
|  | struct sembuf * | sops,
|  | size_t | nsops
| ) | `[static]`

ACE_INLINE int ACE_OS::send | ( | ACE_HANDLE | handle,
|  | const char * | buf,
|  | int | len,
|  | int | flags = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::sendmsg | ( | ACE_HANDLE | handle,
|  | const struct msghdr * | msg,
|  | int | flags
| ) | `[static]`

ACE_INLINE int 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
| ) | `[static]`

ACE_INLINE int ACE_OS::sendto | ( | ACE_HANDLE | handle,
|  | const char * | buf,
|  | int | len,
|  | int | flags,
|  | const struct sockaddr * | addr,
|  | int | addrlen
| ) | `[static]`

ACE_INLINE ssize_t ACE_OS::sendv | ( | ACE_HANDLE | handle,
|  | const iovec * | buffers,
|  | int | n
| ) | `[static]`

ACE_INLINE int ACE_OS::set_errno_to_last_error | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::set_errno_to_wsa_last_error | ( | void |  | ) | `[static]`

ACE_INLINE ACE_EXIT_HOOK ACE_OS::set_exit_hook | ( | ACE_EXIT_HOOK | exit_hook | ) | `[static, private]`

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

int ACE_OS::set_scheduling_params | ( | const ACE_Sched_Params & | sched_params,
|  | ACE_id_t | id = ACE_SELF
| ) | `[static]`

| Friendly interface to <priocntl>(2).

void ACE_OS::set_win32_resource_module | ( | HINSTANCE |  | ) | `[static]`

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

ACE_INLINE int ACE_OS::setgid | ( | gid_t | gid | ) | `[static]`

ACE_INLINE int ACE_OS::setpgid | ( | pid_t | pid,
|  | pid_t | pgid
| ) | `[static]`

ACE_INLINE void ACE_OS::setpwent | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::setregid | ( | gid_t | rgid,
|  | gid_t | egid
| ) | `[static]`

ACE_INLINE int ACE_OS::setreuid | ( | uid_t | ruid,
|  | uid_t | euid
| ) | `[static]`

ACE_INLINE int ACE_OS::setrlimit | ( | int | resource,
|  | ACE_SETRLIMIT_TYPE * | rl
| ) | `[static]`

ACE_INLINE pid_t ACE_OS::setsid | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::setsockopt | ( | ACE_HANDLE | handle,
|  | int | level,
|  | int | optname,
|  | const char * | optval,
|  | int | optlen
| ) | `[static]`

| Manipulate the options associated with a socket.

ACE_INLINE int ACE_OS::setuid | ( | uid_t | uid | ) | `[static]`

ACE_INLINE ACE_HANDLE ACE_OS::shm_open | ( | const ACE_TCHAR * | filename,
|  | int | mode,
|  | int | perms = 0,
|  | LPSECURITY_ATTRIBUTES | sa = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::shm_unlink | ( | const ACE_TCHAR * | path | ) | `[static]`

ACE_INLINE void * ACE_OS::shmat | ( | int | int_id,
|  | void * | shmaddr,
|  | int | shmflg
| ) | `[static]`

ACE_INLINE int ACE_OS::shmctl | ( | int | int_id,
|  | int | cmd,
|  | struct shmid_ds * | buf
| ) | `[static]`

ACE_INLINE int ACE_OS::shmdt | ( | void * | shmaddr | ) | `[static]`

ACE_INLINE int ACE_OS::shmget | ( | key_t | key,
|  | int | size,
|  | int | flags
| ) | `[static]`

ACE_INLINE int ACE_OS::shutdown | ( | ACE_HANDLE | handle,
|  | int | how
| ) | `[static]`

ACE_INLINE int ACE_OS::sigaction | ( | int | signum,
|  | const struct sigaction * | nsa,
|  | struct sigaction * | osa
| ) | `[static]`

ACE_INLINE int ACE_OS::sigaddset | ( | sigset_t * | s,
|  | int | signum
| ) | `[static]`

ACE_INLINE int ACE_OS::sigdelset | ( | sigset_t * | s,
|  | int | signum
| ) | `[static]`

ACE_INLINE int ACE_OS::sigemptyset | ( | sigset_t * | s | ) | `[static]`

ACE_INLINE int ACE_OS::sigfillset | ( | sigset_t * | s | ) | `[static]`

ACE_INLINE int ACE_OS::sigismember | ( | sigset_t * | s,
|  | int | signum
| ) | `[static]`

ACE_INLINE ACE_SignalHandler ACE_OS::signal | ( | int | signum,
|  | ACE_SignalHandler | func
| ) | `[static]`

ACE_INLINE int ACE_OS::sigprocmask | ( | int | how,
|  | const sigset_t * | nsp,
|  | sigset_t * | osp
| ) | `[static]`

ACE_INLINE int ACE_OS::sigsuspend | ( | const sigset_t * | sigset | ) | `[static]`

ACE_INLINE int ACE_OS::sigtimedwait | ( | const sigset_t * | sset,
|  | siginfo_t * | info,
|  | const ACE_Time_Value * | timeout
| ) | `[static]`

int ACE_OS::sigtimedwait_i | ( | const sigset_t * | set,
|  | siginfo_t * | info,
|  | const ACE_Time_Value * | timeout
| ) | `[static, private]`

ACE_INLINE int ACE_OS::sigwait | ( | sigset_t * | sset,
|  | int * | sig = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::sleep | ( | const ACE_Time_Value & | tv | ) | `[static]`

ACE_INLINE int ACE_OS::sleep | ( | u_int | seconds | ) | `[static]`

int ACE_OS::sleep_i | ( | const ACE_Time_Value & | tv | ) | `[static, private]`

int ACE_OS::sleep_i | ( | u_int | seconds | ) | `[static, private]`

ACE_INLINE ACE_HANDLE ACE_OS::socket | ( | int | domain,
|  | int | type,
|  | int | proto,
|  | ACE_Protocol_Info * | protocolinfo,
|  | ACE_SOCK_GROUP | g,
|  | u_long | flags
| ) | `[static]`

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

ACE_INLINE ACE_HANDLE ACE_OS::socket | ( | int | domain,
|  | int | type,
|  | int | proto
| ) | `[static]`

| Create a BSD-style socket (no QoS).

int ACE_OS::socket_fini | ( | void |  | ) | `[static]`

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

int ACE_OS::socket_init | ( | int | version_high = 1,
|  | int | version_low = 1
| ) | `[static]`

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

ACE_INLINE int ACE_OS::socketpair | ( | int | domain,
|  | int | type,
|  | int | protocol,
|  | ACE_HANDLE | sv[2]
| ) | `[static]`

int ACE_OS::sprintf | ( | wchar_t * | buf,
|  | const wchar_t * | format,
|  | ... |
| ) | `[static]`

int ACE_OS::sprintf | ( | char * | buf,
|  | const char * | format,
|  | ... |
| ) | `[static]`

ACE_INLINE void ACE_OS::srand | ( | u_int | seed | ) | `[static]`

ACE_INLINE int ACE_OS::stat | ( | const ACE_TCHAR * | file,
|  | ACE_stat * | stp
| ) | `[static]`

ACE_INLINE int ACE_OS::step | ( | const char * | str,
|  | char * | expbuf
| ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::strenvdup | ( | const ACE_TCHAR * | str | ) | `[static]`

ACE_INLINE size_t ACE_OS::strftime | ( | char * | s,
|  | size_t | maxsize,
|  | const char * | format,
|  | const struct tm * | timeptr
| ) | `[static]`

int ACE_OS::string_to_argv | ( | ACE_TCHAR * | buf,
|  | size_t & | argc,
|  | ACE_TCHAR **& | argv,
|  | int | substitute_env_args = 1
| ) | `[static]`

ACE_INLINE long ACE_OS::sysconf | ( | int | name | ) | `[static]`

ACE_INLINE long ACE_OS::sysinfo | ( | int | cmd,
|  | char * | buf,
|  | long | count
| ) | `[static]`

ACE_INLINE int ACE_OS::system | ( | const ACE_TCHAR * | s | ) | `[static]`

ACE_INLINE ACE_TCHAR * ACE_OS::tempnam | ( | const ACE_TCHAR * | dir = 0,
|  | const ACE_TCHAR * | pfx = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_cancel | ( | ACE_thread_t | thr_id | ) | `[static]`

ACE_INLINE int ACE_OS::thr_cmp | ( | ACE_hthread_t | t1,
|  | ACE_hthread_t | t2
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_continue | ( | ACE_hthread_t | target_thread | ) | `[static]`

int ACE_OS::thr_create | ( | ACE_THR_FUNC | func,
|  | void * | args,
|  | long | flags,
|  | ACE_thread_t * | thr_id,
|  | ACE_hthread_t * | thr_handle = 0,
|  | long | priority = ACE_DEFAULT_THREAD_PRIORITY,
|  | void * | stack = 0,
|  | size_t | stacksize = 0,
|  | ACE_Base_Thread_Adapter * | thread_adapter = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_equal | ( | ACE_thread_t | t1,
|  | ACE_thread_t | t2
| ) | `[static]`

void ACE_OS::thr_exit | ( | void * | status = 0 | ) | `[static]`

ACE_INLINE int ACE_OS::thr_getconcurrency | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::thr_getprio | ( | ACE_hthread_t | thr_id,
|  | int & | prio
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_getspecific | ( | ACE_thread_key_t | key,
|  | void ** | data
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_join | ( | ACE_thread_t | waiter_id,
|  | ACE_thread_t * | thr_id,
|  | void ** | status
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_join | ( | ACE_hthread_t | thr_handle,
|  | void ** | status
| ) | `[static]`

int ACE_OS::thr_key_detach | ( | void * | inst | ) | `[static]`

int ACE_OS::thr_key_used | ( | ACE_thread_key_t | key | ) | `[static]`

int ACE_OS::thr_keycreate | ( | ACE_thread_key_t * | key,
|  | ACE_THR_DEST | dest,
|  | void * | inst = 0
| ) | `[static]`

int ACE_OS::thr_keyfree | ( | ACE_thread_key_t | key | ) | `[static]`

ACE_INLINE int ACE_OS::thr_kill | ( | ACE_thread_t | thr_id,
|  | int | signum
| ) | `[static]`

ACE_INLINE size_t ACE_OS::thr_min_stack | ( | void |  | ) | `[static]`

ACE_INLINE void ACE_OS::thr_self | ( | ACE_hthread_t & | self | ) | `[static]`

ACE_INLINE ACE_thread_t ACE_OS::thr_self | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::thr_setcancelstate | ( | int | new_state,
|  | int * | old_state
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_setcanceltype | ( | int | new_type,
|  | int * | old_type
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_setconcurrency | ( | int | hint | ) | `[static]`

int ACE_OS::thr_setprio | ( | const ACE_Sched_Priority | prio | ) | `[static]`

ACE_INLINE int ACE_OS::thr_setprio | ( | ACE_hthread_t | thr_id,
|  | int | prio
| ) | `[static]`

int ACE_OS::thr_setspecific | ( | ACE_thread_key_t | key,
|  | void * | data
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_sigsetmask | ( | int | how,
|  | const sigset_t * | nsm,
|  | sigset_t * | osm
| ) | `[static]`

ACE_INLINE int ACE_OS::thr_suspend | ( | ACE_hthread_t | target_thread | ) | `[static]`

ACE_INLINE void ACE_OS::thr_testcancel | ( | void |  | ) | `[static]`

ACE_INLINE void ACE_OS::thr_yield | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_destroy | ( | ACE_thread_mutex_t * | m | ) | `[static]`

int ACE_OS::thread_mutex_init | ( | ACE_thread_mutex_t * | m,
|  | int | type,
|  | const wchar_t * | name,
|  | ACE_mutexattr_t * | arg = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_init | ( | ACE_thread_mutex_t * | m,
|  | int | type = ACE_DEFAULT_SYNCH_TYPE,
|  | const char * | name = 0,
|  | ACE_mutexattr_t * | arg = 0
| ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_lock | ( | ACE_thread_mutex_t * | m,
|  | const ACE_Time_Value * | timeout
| ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_lock | ( | ACE_thread_mutex_t * | m,
|  | const ACE_Time_Value & | timeout
| ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_lock | ( | ACE_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_trylock | ( | ACE_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE int ACE_OS::thread_mutex_unlock | ( | ACE_thread_mutex_t * | m | ) | `[static]`

ACE_INLINE time_t ACE_OS::time | ( | time_t * | tloc = 0 | ) | `[static]`

ACE_INLINE long ACE_OS::timezone | ( | void |  | ) | `[static]`

ACE_INLINE int ACE_OS::truncate | ( | const ACE_TCHAR * | filename,
|  | off_t | offset
| ) | `[static]`

ACE_INLINE void ACE_OS::tzset | ( | void |  | ) | `[static]`

ACE_INLINE u_int ACE_OS::ualarm | ( | const ACE_Time_Value & | tv,
|  | const ACE_Time_Value & | tv_interval = ACE_Time_Value::zero
| ) | `[static]`

ACE_INLINE u_int ACE_OS::ualarm | ( | u_int | usecs,
|  | u_int | interval = 0
| ) | `[static]`

u_int ACE_OS::ualarm_i | ( | const ACE_Time_Value & | tv,
|  | const ACE_Time_Value & | tv_interval = ACE_Time_Value::zero
| ) | `[static, private]`

u_int ACE_OS::ualarm_i | ( | u_int | usecs,
|  | u_int | interval = 0
| ) | `[static, private]`

ACE_INLINE mode_t ACE_OS::umask | ( | mode_t | cmask | ) | `[static]`

ACE_INLINE int ACE_OS::uname | ( | ACE_utsname * | name | ) | `[static]`

void ACE_OS::unique_name | ( | const void * | object,
|  | ACE_TCHAR * | name,
|  | size_t | length
| ) | `[static]`

| This method uses process id and object pointer to come up with a machine wide unique name. The process ID will provide uniqueness between processes on the same machine. The "this" pointer of the <object> will provide uniqueness between other "live" objects in the same process. The uniqueness of this name is therefore only valid for the life of <object>.

ACE_INLINE int ACE_OS::unlink | ( | const ACE_TCHAR * | path | ) | `[static]`

int ACE_OS::vsprintf | ( | wchar_t * | buffer,
|  | const wchar_t * | format,
|  | va_list | argptr
| ) | `[static]`

ACE_INLINE int ACE_OS::vsprintf | ( | char * | buffer,
|  | const char * | format,
|  | va_list | argptr
| ) | `[static]`

ACE_INLINE pid_t ACE_OS::wait | ( | int * | status = 0 | ) | `[static]`

| Calls OS <wait> function, so it's only portable to UNIX/POSIX platforms.

ACE_INLINE pid_t ACE_OS::wait | ( | pid_t | pid,
|  | ACE_exitcode * | status,
|  | int | wait_options = 0,
|  | ACE_HANDLE | handle = 0
| ) | `[static]`

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

ACE_INLINE pid_t ACE_OS::waitpid | ( | pid_t | pid,
|  | ACE_exitcode * | status = 0,
|  | int | wait_options = 0,
|  | ACE_HANDLE | handle = 0
| ) | `[static]`

| Calls <waitpid> on UNIX/POSIX platforms and <await> on Chorus. Does not work on Vxworks, or pSoS. 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.

ACE_INLINE ssize_t ACE_OS::write | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | nbyte,
|  | ACE_OVERLAPPED * | overlapped
| ) | `[static]`

ACE_INLINE ssize_t ACE_OS::write | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | nbyte
| ) | `[static]`

ssize_t ACE_OS::write_n | ( | ACE_HANDLE | handle,
|  | const void * | buf,
|  | size_t | len,
|  | size_t * | bt = 0
| ) | `[static]`

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

ACE_INLINE ssize_t ACE_OS::writev | ( | ACE_HANDLE | handle,
|  | const iovec * | iov,
|  | int | iovcnt
| ) | `[static]`

ACE_INLINE int ACE_OS::wscmp | ( | const WChar * | s,
|  | const WChar * | t
| ) | `[static]`

ACE_INLINE ACE_OS::WChar * ACE_OS::wscpy | ( | WChar * | dest,
|  | const WChar * | src
| ) | `[static]`

ACE_INLINE u_int ACE_OS::wslen | ( | const WChar * | s | ) | `[static]`

ACE_INLINE int ACE_OS::wsncmp | ( | const WChar * | s,
|  | const WChar * | t,
|  | size_t | len
| ) | `[static]`

## Friends And Related Function Documentation

friend class ACE_OS_Object_Manager`[friend]`

| Allow the ACE_OS_Object_Manager to call set_exit_hook.

friend class ACE_Timeout_Manager`[friend]`

## Member Data Documentation

ACE_EXIT_HOOK ACE_OS::exit_hook_ = 0`[static, private]`

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

ACE_hthread_t ACE_OS::NULL_hthread`[static]`

| This is necessary to deal with POSIX pthreads and their use of structures for thread handles.

ACE_thread_key_t ACE_OS::NULL_key`[static]`

| This is necessary to deal with POSIX pthreads and their use of structures for TSS keys.

ACE_thread_t ACE_OS::NULL_thread`[static]`

| This is necessary to deal with POSIX pthreads and their use of structures for thread ids.

int ACE_OS::socket_initialized_`[static]`

| Keeps track of whether we've already initialized WinSock...

HINSTANCE ACE_OS::win32_resource_module_`[static, private]`

OSVERSIONINFO ACE_OS::win32_versioninfo_`[static, private]`

The documentation for this class was generated from the following files:

- OS.h
- OS.cpp
- OS.i