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:

Inheritance graph
[legend]
Collaboration diagram for ACE_OS:

Collaboration graph
[legend]
List of all members.

Wide-character strings

typedef ACE_UINT16 WChar
u_int wslen (const WChar *)
WCharwscpy (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)
 This method uses process id and object pointer to come up with a machine wide unique name. More...

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_TCHARstrenvdup (const ACE_TCHAR *str)
ACE_TCHARgetenvstrings (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_TCHARfgets (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)
long ftell (FILE *fp)
int fgetpos (FILE *fp, fpos_t *pos)
int fsetpos (FILE *fp, fpos_t *pos)
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)
 Calls <waitpid> on UNIX/POSIX platforms and <await> on Chorus. More...

pid_t wait (pid_t pid, ACE_exitcode *status, int wait_options=0, ACE_HANDLE handle=0)
 Calls <WaitForSingleObject> on Win32 and <ACE::waitpid> otherwise. More...

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)
 Call TSS destructors for the current thread. More...

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 *)
 Can't call the following priocntl, because that's a macro on Solaris. 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_TCHARdlerror (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_TCHARctime (const time_t *t)
ACE_TCHARctime_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)
 This method attempts to acquire a lock, but gives up if the lock has not been acquired by the given time. More...

int mutex_lock (ACE_mutex_t *m, const ACE_Time_Value *timeout)
 If <timeout> == 0, calls <ACE_OS::mutex_lock(m)>. More...

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

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

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_TCHARmktemp (ACE_TCHAR *t)
ACE_HANDLE mkstemp (ACE_TCHAR *t)
ACE_TCHARgetcwd (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_TCHARtempnam (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)
 QoS-enabled <accept>, which passes <qos_params> to <accept>. More...

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)
 QoS-enabled <connect>, which passes <qos_params> to <connect>. More...

int bind (ACE_HANDLE s, struct sockaddr *name, int namelen)
 BSD-style <accept> (no QoS). More...

int closesocket (ACE_HANDLE s)
 BSD-style <accept> (no QoS). More...

hostent * gethostbyaddr (const char *addr, int length, int type)
 BSD-style <accept> (no QoS). More...

hostent * gethostbyname (const char *name)
 BSD-style <accept> (no QoS). More...

hostent * getipnodebyname (const char *name, int family, int flags=0)
 BSD-style <accept> (no QoS). More...

hostent * getipnodebyaddr (const void *src, size_t len, int family)
 BSD-style <accept> (no QoS). More...

hostent * gethostbyaddr_r (const char *addr, int length, int type, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
 BSD-style <accept> (no QoS). More...

hostent * gethostbyname_r (const char *name, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
 BSD-style <accept> (no QoS). More...

int getpeername (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
 BSD-style <accept> (no QoS). More...

protoent * getprotobyname (const char *name)
 BSD-style <accept> (no QoS). More...

protoent * getprotobyname_r (const char *name, struct protoent *result, ACE_PROTOENT_DATA buffer)
 BSD-style <accept> (no QoS). More...

protoent * getprotobynumber (int proto)
 BSD-style <accept> (no QoS). More...

protoent * getprotobynumber_r (int proto, struct protoent *result, ACE_PROTOENT_DATA buffer)
 BSD-style <accept> (no QoS). More...

servent * getservbyname (const char *svc, const char *proto)
 BSD-style <accept> (no QoS). More...

servent * getservbyname_r (const char *svc, const char *proto, struct servent *result, ACE_SERVENT_DATA buf)
 BSD-style <accept> (no QoS). More...

int getsockname (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
 BSD-style <accept> (no QoS). More...

int getsockopt (ACE_HANDLE handle, int level, int optname, char *optval, int *optlen)
 BSD-style <accept> (no QoS). More...

unsigned long inet_addr (const char *name)
 BSD-style <accept> (no QoS). More...

char * inet_ntoa (const struct in_addr addr)
 BSD-style <accept> (no QoS). More...

int inet_aton (const char *strptr, struct in_addr *addr)
 BSD-style <accept> (no QoS). More...

const char * inet_ntop (int family, const void *addrptr, char *strptr, size_t len)
 BSD-style <accept> (no QoS). More...

int inet_pton (int family, const char *strptr, void *addrptr)
 BSD-style <accept> (no QoS). More...

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)
 BSD-style <accept> (no QoS). More...

int recv (ACE_HANDLE handle, char *buf, int len, int flags=0)
 BSD-style <accept> (no QoS). More...

int recvfrom (ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen)
 BSD-style <accept> (no QoS). More...

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)
 BSD-style <accept> (no QoS). More...

int send (ACE_HANDLE handle, const char *buf, int len, int flags=0)
 BSD-style <accept> (no QoS). More...

int sendto (ACE_HANDLE handle, const char *buf, int len, int flags, const struct sockaddr *addr, int addrlen)
 BSD-style <accept> (no QoS). More...

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)
 BSD-style <accept> (no QoS). More...

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)
 BSD-style <accept> (no QoS). More...

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])
 BSD-style <accept> (no QoS). More...

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]
 

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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 int ACE_OS::fgetpos FILE *    fp,
fpos_t *    pos
[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::fsetpos FILE *    fp,
fpos_t *    pos
[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 long ACE_OS::ftell FILE *    fp [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]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

ACE_INLINE struct hostent * ACE_OS::gethostbyname const char *    name [static]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

ACE_INLINE struct protoent * ACE_OS::getprotobynumber int    proto [static]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

int ACE_OS::inet_aton const char *    host_name,
struct in_addr *    addr
[static]
 

BSD-style <accept> (no QoS).

ACE_INLINE char * ACE_OS::inet_ntoa const struct in_addr    addr [static]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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]
 

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]
 

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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]
 

BSD-style <accept> (no QoS).

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:
Generated on Thu May 23 00:19:40 2002 for ACE by doxygen1.2.13.1 written by Dimitri van Heesch, © 1997-2001