ACE 8.0.1
Loading...
Searching...
No Matches
Classes | Typedefs | Enumerations | Functions | Variables
ACE_OS Namespace Reference

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

Classes

class  ace_flock_t
 OS file locking structure. More...
 
struct  macaddr_node_t
 

Typedefs

typedef ACE_WCHAR_T WChar
 

Enumerations

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

Functions

unsigned long inet_addr (const char *name)
 
int inet_aton (const char *strptr, struct in_addr *addr)
 
charinet_ntoa (const struct in_addr addr)
 
const charinet_ntop (int family, const void *addrptr, char *strptr, size_t len)
 
int inet_pton (int family, const char *strptr, void *addrptr)
 
int posix_devctl (int filedes, int dcmd, void *dev_data_ptr, size_t nbyte, int *dev_info_ptr)
 
void closedir (ACE_DIR *)
 
ACE_DIRopendir (const ACE_TCHAR *filename)
 
struct ACE_DIRENTreaddir (ACE_DIR *)
 
void rewinddir (ACE_DIR *)
 
int scandir (const ACE_TCHAR *dirname, struct ACE_DIRENT **namelist[], ACE_SCANDIR_SELECTOR selector, ACE_SCANDIR_COMPARATOR comparator)
 
int alphasort (const void *, const void *)
 
void seekdir (ACE_DIR *, long loc)
 
long telldir (ACE_DIR *)
 
int scandir_emulation (const ACE_TCHAR *dirname, ACE_DIRENT **namelist[], ACE_SCANDIR_SELECTOR selector, ACE_SCANDIR_COMPARATOR comparator)
 
int dlclose (ACE_SHLIB_HANDLE handle)
 
ACE_TCHARdlerror ()
 
ACE_SHLIB_HANDLE dlopen (const ACE_TCHAR *filename, int mode=ACE_DEFAULT_SHLIB_MODE)
 
voiddlsym (ACE_SHLIB_HANDLE handle, const ACE_TCHAR *symbol)
 
int last_error ()
 
void last_error (int error)
 
int set_errno_to_last_error ()
 
int set_errno_to_wsa_last_error ()
 
int fcntl (ACE_HANDLE handle, int cmd, long arg=0)
 
ACE_HANDLE open (const char *filename, int mode, mode_t perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
 
ACE_HANDLE open (const wchar_t *filename, int mode, mode_t perms=ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa=0)
 
template<typename T >
floor (T x)
 This method computes the largest integral value not greater than x.
 
template<typename T >
ceil (T x)
 This method computes the smallest integral value not less than x.
 
double log2 (double x)
 This method computes the base-2 logarithm of x.
 
struct hostentgethostbyaddr (const char *addr, int length, int type)
 
struct hostentgethostbyaddr_r (const char *addr, int length, int type, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
 
struct hostentgethostbyname (const char *name)
 
struct hostentgethostbyname_r (const char *name, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop)
 
struct hostentgetipnodebyaddr (const void *src, size_t len, int family)
 
struct hostentgetipnodebyname (const char *name, int family, int flags=0)
 
int getmacaddress (struct macaddr_node_t *node)
 
struct protoentgetprotobyname (const char *name)
 
struct protoentgetprotobyname_r (const char *name, struct protoent *result, ACE_PROTOENT_DATA buffer)
 
struct protoentgetprotobynumber (int proto)
 
struct protoentgetprotobynumber_r (int proto, struct protoent *result, ACE_PROTOENT_DATA buffer)
 
struct serventgetservbyname (const char *svc, const char *proto)
 
struct serventgetservbyname_r (const char *svc, const char *proto, struct servent *result, ACE_SERVENT_DATA buf)
 
int getaddrinfo (const char *name, const char *service, const addrinfo *hints, addrinfo **result)
 
void freeaddrinfo (addrinfo *result)
 
const ACE_TCHARgai_strerror (int errcode)
 
int getnameinfo (const sockaddr *addr, ACE_SOCKET_LEN addr_len, char *host, ACE_SOCKET_LEN host_len, char *service, ACE_SOCKET_LEN service_len, unsigned int flags)
 
int poll (struct pollfd *pollfds, unsigned long len, const ACE_Time_Value *tv=0)
 
int poll (struct pollfd *pollfds, unsigned long len, const ACE_Time_Value &tv)
 
void endpwent ()
 
struct passwdgetpwent ()
 
struct passwdgetpwnam (const char *user)
 
int getpwnam_r (const char *name, struct passwd *pwd, char *buffer, size_t bufsize, struct passwd **result)
 
void setpwent ()
 
charcompile (const char *instring, char *expbuf, char *endbuf)
 
int step (const char *str, char *expbuf)
 
int kill (pid_t pid, int signum)
 
int pthread_sigmask (int how, const sigset_t *nsp, sigset_t *osp)
 
int sigaction (int signum, const ACE_SIGACTION *nsa, ACE_SIGACTION *osa)
 
int sigaddset (sigset_t *s, int signum)
 
int sigdelset (sigset_t *s, int signum)
 
int sigemptyset (sigset_t *s)
 
int sigfillset (sigset_t *s)
 
int sigismember (sigset_t *s, int signum)
 
ACE_SignalHandler signal (int signum, ACE_SignalHandler)
 
int sigprocmask (int how, const sigset_t *nsp, sigset_t *osp)
 
int sigsuspend (const sigset_t *s)
 
int raise (const int signum)
 
void clearerr (FILE *fp)
 
charcuserid (char *user, size_t maxlen=ACE_MAX_USERID)
 
wchar_tcuserid (wchar_t *user, size_t maxlen=ACE_MAX_USERID)
 
int asprintf (char **bufp, const char *format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int asprintf (wchar_t **bufp, const wchar_t *format,...)
 
int fclose (FILE *fp)
 
FILEfdopen (ACE_HANDLE handle, const ACE_TCHAR *mode)
 
int fflush (FILE *fp)
 
int fgetc (FILE *fp)
 
int getc (FILE *fp)
 
int fgetpos (FILE *fp, fpos_t *pos)
 
charfgets (char *buf, int size, FILE *fp)
 
wchar_tfgets (wchar_t *buf, int size, FILE *fp)
 
void flock_adjust_params (ace_flock_t *lock, short whence, ACE_OFF_T &start, ACE_OFF_T &len)
 
int flock_init (ace_flock_t *lock, int flags=0, const ACE_TCHAR *name=0, mode_t perms=0)
 
int flock_destroy (ace_flock_t *lock, int unlink_file=1)
 
int flock_rdlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)
 
int flock_tryrdlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)
 
int flock_trywrlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)
 
int flock_unlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)
 
int flock_wrlock (ace_flock_t *lock, short whence=0, ACE_OFF_T start=0, ACE_OFF_T len=0)
 
ACE_HANDLE fileno (FILE *stream)
 
FILEfopen (const char *filename, const char *mode)
 
FILEfopen (const char *filename, const wchar_t *mode)
 
FILEfopen (const wchar_t *filename, const wchar_t *mode)
 
FILEfopen (const wchar_t *filename, const char *mode)
 
LPSECURITY_ATTRIBUTES default_win32_security_attributes (LPSECURITY_ATTRIBUTES)
 Default Win32 Security Attributes definition.
 
LPSECURITY_ATTRIBUTES default_win32_security_attributes_r (LPSECURITY_ATTRIBUTES, LPSECURITY_ATTRIBUTES, SECURITY_DESCRIPTOR *)
 
const ACE_TEXT_OSVERSIONINFOget_win32_versioninfo ()
 Return the win32 OSVERSIONINFO structure.
 
HINSTANCE get_win32_resource_module ()
 
void set_win32_resource_module (HINSTANCE)
 
int fprintf (FILE *fp, const char *format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int fprintf (FILE *fp, const wchar_t *format,...)
 
int ungetc (int c, FILE *fp)
 
int fputc (int c, FILE *fp)
 
int putc (int c, FILE *fp)
 
int fputs (const char *s, FILE *stream)
 
int fputs (const wchar_t *s, FILE *stream)
 
size_t fread (void *ptr, size_t size, size_t nelems, FILE *fp)
 
FILEfreopen (const ACE_TCHAR *filename, const ACE_TCHAR *mode, FILE *stream)
 
int fseek (FILE *fp, long offset, int ptrname)
 
int fsetpos (FILE *fp, fpos_t *pos)
 
long ftell (FILE *fp)
 
size_t fwrite (const void *ptr, size_t size, size_t nitems, FILE *fp)
 
void perror (const char *s)
 
void perror (const wchar_t *s)
 
int printf (const char *format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int printf (const wchar_t *format,...)
 
int puts (const char *s)
 
int puts (const wchar_t *s)
 
int rename (const char *old_name, const char *new_name, int flags=-1)
 
int rename (const wchar_t *old_name, const wchar_t *new_name, int flags=-1)
 
void rewind (FILE *fp)
 
int snprintf (char *buf, size_t maxlen, const char *format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int snprintf (wchar_t *buf, size_t maxlen, const wchar_t *format,...)
 
int sprintf (char *buf, const char *format,...) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int sprintf (wchar_t *buf, const wchar_t *format,...)
 
chartempnam (const char *dir=0, const char *pfx=0)
 
wchar_ttempnam (const wchar_t *dir, const wchar_t *pfx=0)
 
int vasprintf (char **bufp, const char *format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int vprintf (const char *format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int int vfprintf (FILE *fp, const char *format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int int int vsprintf (char *buffer, const char *format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int int int int vsnprintf (char *buffer, size_t maxlen, const char *format, va_list argptr) ACE_GCC_FORMAT_ATTRIBUTE(printf
 
int int int int int int vasprintf (wchar_t **bufp, const wchar_t *format, va_list argptr)
 
int vprintf (const wchar_t *format, va_list argptr)
 
int vfprintf (FILE *fp, const wchar_t *format, va_list argptr)
 
int vsprintf (wchar_t *buffer, const wchar_t *format, va_list argptr)
 
int vsnprintf (wchar_t *buffer, size_t maxlen, const wchar_t *format, va_list argptr)
 
int vasprintf_emulation (char **bufp, const char *format, va_list argptr)
 
int vaswprintf_emulation (wchar_t **bufp, const wchar_t *format, va_list argptr)
 
int strcasecmp (const char *s, const char *t)
 Compares two strings (case insensitive const char version).
 
int strcasecmp (const wchar_t *s, const wchar_t *t)
 Compares two strings (case insensitive const wchar_t version).
 
int strncasecmp (const char *s, const char *t, size_t len)
 Compares two arrays (case insensitive const char version).
 
int strncasecmp (const wchar_t *s, const wchar_t *t, size_t len)
 Compares two arrays (case insensitive const wchar_t version).
 
int getmsg (ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *flags)
 
int getpmsg (ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *band, int *flags)
 
int fattach (int handle, const char *path)
 
int fdetach (const char *file)
 
int ioctl (ACE_HANDLE handle, ACE_IOCTL_TYPE_ARG2 cmd, void *=0)
 UNIX-style ioctl.
 
int ioctl (ACE_HANDLE socket, unsigned long io_control_code, void *in_buffer_p, unsigned long in_buffer, void *out_buffer_p, unsigned long out_buffer, unsigned long *bytes_returned, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
 QoS-enabled ioctl.
 
int ioctl (ACE_HANDLE socket, unsigned long io_control_code, ACE_QoS &ace_qos, unsigned long *bytes_returned, void *buffer_p=0, unsigned long buffer=0, ACE_OVERLAPPED *overlapped=0, ACE_OVERLAPPED_COMPLETION_FUNC func=0)
 
int isastream (ACE_HANDLE handle)
 
int putmsg (ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int flags)
 
int putpmsg (ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int band, int flags)
 
int madvise (caddr_t addr, size_t len, int map_advice)
 
voidmmap (void *addr, size_t len, int prot, int flags, ACE_HANDLE handle, ACE_OFF_T off=0, ACE_HANDLE *file_mapping=0, LPSECURITY_ATTRIBUTES sa=0, const ACE_TCHAR *file_mapping_name=0)
 
int mprotect (void *addr, size_t len, int prot)
 
int msync (void *addr, size_t len, int sync)
 
int munmap (void *addr, size_t len)
 
ACE_HANDLE shm_open (const ACE_TCHAR *filename, int mode, mode_t perms=0, LPSECURITY_ATTRIBUTES sa=0)
 
int shm_unlink (const ACE_TCHAR *path)
 
int msgctl (int msqid, int cmd, struct msqid_ds *)
 
int msgget (key_t key, int msgflg)
 
ssize_t msgrcv (int int_id, void *buf, size_t len, long type, int flags)
 
int msgsnd (int int_id, const void *buf, size_t len, int flags)
 
int getrlimit (int resource, struct rlimit *rl)
 
int getrusage (int who, struct rusage *rusage)
 
int setrlimit (int resource, const struct rlimit *rl)
 
int select (int width, fd_set *rfds, fd_set *wfds=0, fd_set *efds=0, const ACE_Time_Value *tv=0)
 
int select (int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv)
 
ssize_t sendfile (ACE_HANDLE out_fd, ACE_HANDLE in_fd, off_t *offset, size_t count)
 Wrapper for sendfile to transfer data between file descriptor.
 
voidshmat (int int_id, const void *shmaddr, int shmflg)
 
int shmctl (int int_id, int cmd, struct shmid_ds *buf)
 
int shmdt (const void *shmaddr)
 
int shmget (key_t key, size_t size, int flags)
 
ACE_HANDLE accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
 BSD-style accept (no QoS).
 
ACE_HANDLE accept (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen, const ACE_Accept_QoS_Params &qos_params)
 
int bind (ACE_HANDLE s, struct sockaddr *name, int namelen)
 
int closesocket (ACE_HANDLE s)
 Takes care of windows specific requirement to call closesocket.
 
int connect (ACE_HANDLE handle, struct sockaddr *addr, int addrlen)
 BSD-style connect (no QoS).
 
int connect (ACE_HANDLE handle, const sockaddr *addr, int addrlen, const ACE_QoS_Params &qos_params)
 
int enum_protocols (int *protocols, ACE_Protocol_Info *protocol_buffer, u_long *buffer_length)
 
int getpeername (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
 
int getsockname (ACE_HANDLE handle, struct sockaddr *addr, int *addrlen)
 
int getsockopt (ACE_HANDLE handle, int level, int optname, char *optval, int *optlen)
 
ACE_HANDLE join_leaf (ACE_HANDLE socket, const sockaddr *name, int namelen, const ACE_QoS_Params &qos_params)
 Joins a leaf node into a QoS-enabled multi-point session.
 
int listen (ACE_HANDLE handle, int backlog)
 
ssize_t recv (ACE_HANDLE handle, char *buf, size_t len, int flags=0)
 
ssize_t recvfrom (ACE_HANDLE handle, char *buf, size_t len, int flags, struct sockaddr *addr, int *addrlen)
 
ssize_t recvfrom (ACE_HANDLE handle, iovec *buffers, int buffer_count, size_t &number_of_bytes_recvd, int &flags, struct sockaddr *addr, int *addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
 
ssize_t recvmsg (ACE_HANDLE handle, struct msghdr *msg, int flags)
 
ssize_t recvv (ACE_HANDLE handle, iovec *iov, int iovlen)
 
ssize_t send (ACE_HANDLE handle, const char *buf, size_t len, int flags=0)
 
ssize_t send_partial_i (ACE_HANDLE handle, const char *buf, size_t len, int flags)
 
ssize_t sendmsg (ACE_HANDLE handle, const struct msghdr *msg, int flags)
 
ssize_t sendto (ACE_HANDLE handle, const char *buf, size_t len, int flags, const struct sockaddr *addr, int addrlen)
 
ssize_t sendto (ACE_HANDLE handle, const iovec *buffers, int buffer_count, size_t &number_of_bytes_sent, int flags, const struct sockaddr *addr, int addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func)
 
ssize_t sendv (ACE_HANDLE handle, const iovec *iov, int iovcnt)
 
ssize_t sendv_partial_i (ACE_HANDLE handle, const iovec *iov, int iovcnt)
 
int setsockopt (ACE_HANDLE handle, int level, int optname, const char *optval, int optlen)
 Manipulate the options associated with a socket.
 
int shutdown (ACE_HANDLE handle, int how)
 
unsigned int if_nametoindex (const char *ifname)
 
charif_indextoname (unsigned int ifindex, char *ifname)
 
struct if_nameindex * if_nameindex ()
 
void if_freenameindex (struct if_nameindex *ptr)
 
int socket_init (int version_high=1, int version_low=1)
 
int socket_fini ()
 Finalize WinSock after last use (e.g., when a DLL is unloaded).
 
ACE_HANDLE socket (int protocol_family, int type, int proto)
 Create a BSD-style socket (no QoS).
 
ACE_HANDLE socket (int protocol_family, int type, int proto, ACE_Protocol_Info *protocolinfo, ACE_SOCK_GROUP g, u_long flags)
 
int socketpair (int domain, int type, int protocol, ACE_HANDLE sv[2])
 
ACE_HANDLE creat (const ACE_TCHAR *filename, mode_t mode)
 
ACE_OFF_T filesize (ACE_HANDLE handle)
 
ACE_OFF_T filesize (const ACE_TCHAR *handle)
 
int fstat (ACE_HANDLE, ACE_stat *)
 
int lstat (const char *, ACE_stat *)
 
int lstat (const wchar_t *, ACE_stat *)
 
int mkdir (const char *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)
 
int mkdir (const wchar_t *path, mode_t mode=ACE_DEFAULT_DIR_PERMS)
 
int mkfifo (const ACE_TCHAR *file, mode_t mode=ACE_DEFAULT_FILE_PERMS)
 
int stat (const char *file, ACE_stat *)
 
int stat (const wchar_t *file, ACE_stat *)
 
mode_t umask (mode_t cmask)
 
ACE_Time_Value gettimeofday ()
 
ACE_Time_Value gettimeofday_ ()
 
ssize_t readv (ACE_HANDLE handle, const iovec *iov, int iovlen)
 
ssize_t writev (ACE_HANDLE handle, const iovec *iov, int iovcnt)
 
int uname (ACE_utsname *name)
 
pid_t wait (int *=0)
 
pid_t wait (pid_t pid, ACE_exitcode *status, int wait_options=0, ACE_HANDLE handle=0)
 
pid_t waitpid (pid_t pid, ACE_exitcode *status=0, int wait_options=0, ACE_HANDLE handle=0)
 
void cleanup_tss (const u_int main_thread)
 
int condattr_init (ACE_condattr_t &attributes, int type=ACE_DEFAULT_SYNCH_TYPE)
 
int condattr_synctype (ACE_condattr_t &attributes, int &type)
 
int condattr_destroy (ACE_condattr_t &attributes)
 
int condattr_setclock (ACE_condattr_t &attributes, clockid_t clock_id)
 
int cond_broadcast (ACE_cond_t *cv)
 
int cond_destroy (ACE_cond_t *cv)
 
int cond_init (ACE_cond_t *cv, short type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0)
 
int cond_init (ACE_cond_t *cv, ACE_condattr_t &attributes, const char *name=0, void *arg=0)
 
int cond_init (ACE_cond_t *cv, short type, const wchar_t *name, void *arg=0)
 
int cond_init (ACE_cond_t *cv, ACE_condattr_t &attributes, const wchar_t *name, void *arg=0)
 
int cond_signal (ACE_cond_t *cv)
 
int cond_timedwait (ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *timeout)
 
int cond_wait (ACE_cond_t *cv, ACE_mutex_t *m)
 
int event_destroy (ACE_event_t *event)
 
int event_init (ACE_event_t *event, int manual_reset=0, int initial_state=0, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
 
int event_init (ACE_event_t *event, int type, ACE_condattr_t *attributes, int manual_reset=0, int initial_state=0, const char *name=0, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
 
int event_init (ACE_event_t *event, int manual_reset, int initial_state, int type, const wchar_t *name, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
 
int event_init (ACE_event_t *event, int type, ACE_condattr_t *attributes, int manual_reset, int initial_state, const wchar_t *name, void *arg=0, LPSECURITY_ATTRIBUTES sa=0)
 
int event_pulse (ACE_event_t *event)
 
int event_reset (ACE_event_t *event)
 
int event_signal (ACE_event_t *event)
 
int event_timedwait (ACE_event_t *event, ACE_Time_Value *timeout, int use_absolute_time=1)
 
int event_wait (ACE_event_t *event)
 
int lwp_getparams (ACE_Sched_Params &)
 
int lwp_setparams (const ACE_Sched_Params &)
 
int mutex_destroy (ACE_mutex_t *m)
 
int mutex_init (ACE_mutex_t *m, int lock_scope=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0, int lock_type=0)
 
int mutex_init (ACE_mutex_t *m, int lock_scope, const wchar_t *name, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0, int lock_type=0)
 
int mutex_lock (ACE_mutex_t *m)
 
int mutex_lock (ACE_mutex_t *m, int &abandoned)
 
int mutex_lock (ACE_mutex_t *m, const ACE_Time_Value &timeout)
 
int mutex_lock (ACE_mutex_t *m, const ACE_Time_Value *timeout)
 
void mutex_lock_cleanup (void *mutex)
 Handle asynchronous thread cancellation cleanup.
 
int mutex_trylock (ACE_mutex_t *m)
 
int mutex_trylock (ACE_mutex_t *m, int &abandoned)
 
int mutex_unlock (ACE_mutex_t *m)
 
long priority_control (ACE_idtype_t, ACE_id_t, int, void *)
 Low-level interface to priocntl(2).
 
int recursive_mutex_cond_unlock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)
 
void recursive_mutex_cond_relock (ACE_recursive_thread_mutex_t *m, ACE_recursive_mutex_state &state)
 
int recursive_mutex_destroy (ACE_recursive_thread_mutex_t *m)
 
int recursive_mutex_init (ACE_recursive_thread_mutex_t *m, const ACE_TCHAR *name=0, ACE_mutexattr_t *arg=0, LPSECURITY_ATTRIBUTES sa=0)
 
int recursive_mutex_lock (ACE_recursive_thread_mutex_t *m)
 
int recursive_mutex_lock (ACE_recursive_thread_mutex_t *m, const ACE_Time_Value &timeout)
 
int recursive_mutex_lock (ACE_recursive_thread_mutex_t *m, const ACE_Time_Value *timeout)
 
int recursive_mutex_trylock (ACE_recursive_thread_mutex_t *m)
 
int recursive_mutex_unlock (ACE_recursive_thread_mutex_t *m)
 
int rw_rdlock (ACE_rwlock_t *rw)
 
int rw_tryrdlock (ACE_rwlock_t *rw)
 
int rw_trywrlock (ACE_rwlock_t *rw)
 
int rw_trywrlock_upgrade (ACE_rwlock_t *rw)
 
int rw_unlock (ACE_rwlock_t *rw)
 
int rw_wrlock (ACE_rwlock_t *rw)
 
int rwlock_destroy (ACE_rwlock_t *rw)
 
int rwlock_init (ACE_rwlock_t *rw, int type=ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR *name=0, void *arg=0)
 
int sched_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
 
int scheduling_class (const char *class_name, ACE_id_t &)
 Find the scheduling class ID that corresponds to the class name.
 
int sema_destroy (ACE_sema_t *s)
 
int sema_init (ACE_sema_t *s, u_int count, int type=ACE_DEFAULT_SYNCH_TYPE, const char *name=0, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
 
int sema_init (ACE_sema_t *s, u_int count, int type, ACE_condattr_t *attributes, const char *name=0, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
 
int sema_init (ACE_sema_t *s, u_int count, int type, const wchar_t *name, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
 
int sema_init (ACE_sema_t *s, u_int count, int type, ACE_condattr_t *attributes, const wchar_t *name, void *arg=0, int max=0x7fffffff, LPSECURITY_ATTRIBUTES sa=0)
 
void sema_avoid_unlink (ACE_sema_t *s, bool avoid_unlink)
 
int sema_unlink (const char *name)
 
int sema_post (ACE_sema_t *s)
 
int sema_post (ACE_sema_t *s, u_int release_count)
 
int sema_trywait (ACE_sema_t *s)
 
int sema_wait (ACE_sema_t *s)
 
int sema_wait (ACE_sema_t *s, ACE_Time_Value &tv)
 
int sema_wait (ACE_sema_t *s, ACE_Time_Value *tv)
 
int semctl (int int_id, int semnum, int cmd, semun)
 
int semget (key_t key, int nsems, int flags)
 
int semop (int int_id, struct sembuf *sops, size_t nsops)
 
int set_scheduling_params (const ACE_Sched_Params &, ACE_id_t id=ACE_SELF)
 Friendly interface to priocntl(2).
 
int sigtimedwait (const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout)
 
int sigwait (sigset_t *set, int *sig=0)
 
int sigwaitinfo (const sigset_t *set, siginfo_t *info)
 
int thr_cancel (ACE_thread_t t_id)
 
int thr_cmp (ACE_hthread_t t1, ACE_hthread_t t2)
 
int thr_continue (ACE_hthread_t target_thread)
 
int thr_create (ACE_THR_FUNC func, void *args, long flags, ACE_thread_t *thr_id, ACE_hthread_t *t_handle=0, long priority=ACE_DEFAULT_THREAD_PRIORITY, void *stack=0, size_t stacksize=ACE_DEFAULT_THREAD_STACKSIZE, ACE_Base_Thread_Adapter *thread_adapter=0, const char **thr_name=0)
 
int thr_equal (ACE_thread_t t1, ACE_thread_t t2)
 
void thr_exit (ACE_THR_FUNC_RETURN status=0)
 
int thr_getconcurrency ()
 
int thr_getprio (ACE_hthread_t id, int &priority)
 
int thr_getprio (ACE_hthread_t id, int &priority, int &policy)
 
int thr_getspecific (ACE_thread_key_t key, void **data)
 
int thr_join (ACE_hthread_t waiter_id, ACE_THR_FUNC_RETURN *status)
 
int thr_join (ACE_thread_t waiter_id, ACE_thread_t *thr_id, ACE_THR_FUNC_RETURN *status)
 
int thr_get_affinity (ACE_hthread_t thr_id, size_t cpu_set_size, cpu_set_t *cpu_mask)
 
int thr_set_affinity (ACE_hthread_t thr_id, size_t cpu_set_size, const cpu_set_t *cpu_mask)
 
int thr_key_detach (ACE_thread_key_t key)
 
int thr_key_used (ACE_thread_key_t key)
 
int thr_keycreate (ACE_thread_key_t *key, ACE_THR_DEST)
 
int thr_keyfree (ACE_thread_key_t key)
 
int thr_kill (ACE_thread_t thr_id, int signum)
 
size_t thr_min_stack ()
 
ACE_thread_t thr_self ()
 
void thr_self (ACE_hthread_t &)
 
const charthr_name ()
 
ssize_t thr_id (char buffer[], size_t buffer_length)
 
pid_t thr_gettid ()
 
ssize_t thr_gettid (char buffer[], size_t buffer_length)
 
int thr_setcancelstate (int new_state, int *old_state)
 State is THR_CANCEL_ENABLE or THR_CANCEL_DISABLE.
 
int thr_setcanceltype (int new_type, int *old_type)
 Type is THR_CANCEL_DEFERRED or THR_CANCEL_ASYNCHRONOUS.
 
int thr_setconcurrency (int hint)
 
int thr_setprio (ACE_hthread_t ht_id, int priority, int policy=-1)
 
int thr_setprio (const ACE_Sched_Priority prio)
 
int thr_setspecific (ACE_thread_key_t key, void *data)
 
int thr_sigsetmask (int how, const sigset_t *nsm, sigset_t *osm)
 
int thr_suspend (ACE_hthread_t target_thread)
 
void thr_testcancel ()
 
void thr_yield ()
 
int thread_mutex_destroy (ACE_thread_mutex_t *m)
 
int thread_mutex_init (ACE_thread_mutex_t *m, int lock_type=0, const char *name=0, ACE_mutexattr_t *arg=0)
 
int thread_mutex_init (ACE_thread_mutex_t *m, int lock_type, const wchar_t *name, ACE_mutexattr_t *arg=0)
 
int thread_mutex_lock (ACE_thread_mutex_t *m)
 
int thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value &timeout)
 
int thread_mutex_lock (ACE_thread_mutex_t *m, const ACE_Time_Value *timeout)
 
int thread_mutex_trylock (ACE_thread_mutex_t *m)
 
int thread_mutex_unlock (ACE_thread_mutex_t *m)
 
void unique_name (const void *object, char *name, size_t length)
 
charasctime (const struct tm *tm)
 
charasctime_r (const struct tm *tm, char *buf, int buflen)
 
int clock_gettime (clockid_t, struct timespec *)
 
int clock_settime (clockid_t, const struct timespec *)
 
ACE_TCHARctime (const time_t *t)
 
ACE_TCHARctime_r (const time_t *clock, ACE_TCHAR *buf, int buflen)
 
double difftime (time_t t1, time_t t0)
 
ACE_hrtime_t gethrtime (const ACE_HRTimer_Op=ACE_HRTIMER_GETTIME)
 
struct tm * gmtime (const time_t *clock)
 
struct tm * gmtime_r (const time_t *clock, struct tm *res)
 
struct tm * localtime (const time_t *clock)
 
struct tm * localtime_r (const time_t *clock, struct tm *res)
 
time_t mktime (struct tm *timeptr)
 
int nanosleep (const struct timespec *requested, struct timespec *remaining=0)
 
size_t strftime (char *s, size_t maxsize, const char *format, const struct tm *timeptr) ACE_GCC_FORMAT_ATTRIBUTE(strftime
 
size_t charstrptime (const char *buf, const char *format, struct tm *tm)
 
time_t time (time_t *tloc=0)
 
long timezone ()
 
void tzset ()
 
int access (const char *path, int amode)
 
int access (const wchar_t *path, int amode)
 
unsigned int alarm (u_int secs)
 
long allocation_granularity ()
 
int argv_to_string (int argc, ACE_TCHAR **argv, ACE_TCHAR *&buf, bool substitute_env_args=true, bool quote_args=false)
 used by ARGV::argv_to_string() and ACE_OS::fork_exec()
 
int argv_to_string (ACE_TCHAR **argv, ACE_TCHAR *&buf, bool substitute_env_args=true, bool quote_args=false)
 
int chdir (const char *path)
 
int chdir (const wchar_t *path)
 
int rmdir (const char *path)
 
int rmdir (const wchar_t *path)
 
int close (ACE_HANDLE handle)
 
ACE_HANDLE dup (ACE_HANDLE handle)
 
ACE_HANDLE dup (ACE_HANDLE handle, pid_t pid)
 
int dup2 (ACE_HANDLE oldfd, ACE_HANDLE newfd)
 
int execl (const char *path, const char *arg0,...)
 
int execle (const char *path, const char *arg0,...)
 
int execlp (const char *file, const char *arg0,...)
 
int execv (const char *path, char *const argv[])
 
int execve (const char *path, char *const argv[], char *const envp[])
 
int execvp (const char *file, char *const argv[])
 
pid_t fork ()
 
pid_t fork (const ACE_TCHAR *program_name)
 
pid_t fork_exec (ACE_TCHAR *argv[])
 
int fsync (ACE_HANDLE handle)
 
int ftruncate (ACE_HANDLE handle, ACE_OFF_T offset)
 
chargetcwd (char *, size_t)
 
wchar_tgetcwd (wchar_t *, size_t)
 
gid_t getgid ()
 
gid_t getegid ()
 
int getopt (int argc, char *const *argv, const char *optstring)
 
long getpagesize ()
 
pid_t getpgid (pid_t pid)
 
pid_t getpid ()
 
pid_t getppid ()
 
uid_t getuid ()
 
uid_t geteuid ()
 
int hostname (char name[], size_t maxnamelen)
 
int hostname (wchar_t name[], size_t maxnamelen)
 
int isatty (int handle)
 
int isatty (ACE_HANDLE handle)
 
ACE_OFF_T lseek (ACE_HANDLE handle, ACE_OFF_T offset, int whence)
 
long num_processors ()
 Get the number of CPUs configured in the machine.
 
long num_processors_online ()
 Get the number of CPUs currently online.
 
int pipe (ACE_HANDLE handles[])
 
ssize_t pread (ACE_HANDLE handle, void *buf, size_t nbyte, ACE_OFF_T offset)
 
ssize_t pwrite (ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_OFF_T offset)
 
ssize_t read (ACE_HANDLE handle, void *buf, size_t len)
 
ssize_t read (ACE_HANDLE handle, void *buf, size_t len, ACE_OVERLAPPED *)
 
ssize_t read_n (ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred=0)
 
ssize_t readlink (const char *path, char *buf, size_t bufsiz)
 
voidsbrk (intptr_t brk)
 
int setgid (gid_t)
 
int setegid (gid_t)
 
int setpgid (pid_t pid, pid_t pgid)
 
int setregid (gid_t rgid, gid_t egid)
 
int setreuid (uid_t ruid, uid_t euid)
 
pid_t setsid ()
 
int setuid (uid_t)
 
int seteuid (uid_t)
 
int sleep (u_int seconds)
 
int sleep (const ACE_Time_Value &tv)
 
int string_to_argv (ACE_TCHAR *buf, int &argc, ACE_TCHAR **&argv, bool substitute_env_args=true)
 
void swab (const void *src, void *dest, ssize_t n)
 
long sysconf (int)
 
long sysinfo (int cmd, char *buf, long count)
 
int truncate (const ACE_TCHAR *filename, ACE_OFF_T length)
 
useconds_t ualarm (useconds_t usecs, useconds_t interval=0)
 
useconds_t ualarm (const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval=ACE_Time_Value::zero)
 
int unlink (const char *path)
 
int unlink (const wchar_t *path)
 
ssize_t write (ACE_HANDLE handle, const void *buf, size_t nbyte)
 
ssize_t write (ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_OVERLAPPED *)
 
ssize_t write_n (ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred=0)
 
wint_t fgetwc (FILE *fp)
 
u_int wslen (const WChar *)
 
WCharwscpy (WChar *, const WChar *)
 
int wscmp (const WChar *, const WChar *)
 
int wsncmp (const WChar *, const WChar *, size_t len)
 
wint_t ungetwc (wint_t c, FILE *fp)
 
int t_accept (ACE_HANDLE fildes, ACE_HANDLE resfd, struct t_call *call)
 
chart_alloc (ACE_HANDLE fildes, int struct_type, int fields)
 
int t_bind (ACE_HANDLE fildes, ACE_TBIND *req, ACE_TBIND *ret)
 
int t_close (ACE_HANDLE fildes)
 
int t_connect (ACE_HANDLE fildes, struct t_call *sndcall, struct t_call *rcvcall)
 
void t_error (const char *errmsg)
 
int t_free (char *ptr, int struct_type)
 
int t_getinfo (ACE_HANDLE fildes, struct t_info *info)
 
int t_getname (ACE_HANDLE fildes, struct netbuf *namep, int type)
 
int t_getstate (ACE_HANDLE fildes)
 
int t_listen (ACE_HANDLE fildes, struct t_call *call)
 
int t_look (ACE_HANDLE fildes)
 
ACE_HANDLE t_open (char *path, int oflag, struct t_info *info)
 
int t_optmgmt (ACE_HANDLE handle, ACE_TOPTMGMT *req, ACE_TOPTMGMT *ret)
 
int t_rcv (ACE_HANDLE fildes, char *buf, unsigned int nbytes, int *flags)
 
int t_rcvdis (ACE_HANDLE fildes, struct t_discon *discon)
 
int t_rcvrel (ACE_HANDLE fildes)
 
int t_rcvudata (ACE_HANDLE fildes, struct t_unitdata *unitdata, int *flags)
 
int t_rcvuderr (ACE_HANDLE fildes, struct t_uderr *uderr)
 
int t_snd (ACE_HANDLE fildes, const char *buf, unsigned int nbytes, int flags)
 
int t_snddis (ACE_HANDLE fildes, struct t_call *call)
 
int t_sndrel (ACE_HANDLE fildes)
 
int t_sync (ACE_HANDLE fildes)
 
int t_unbind (ACE_HANDLE fildes)
 
Functions from <cctype>

Included are the functions defined in <cctype> and their <cwctype> equivalents.

Since they are often implemented as macros, we don't use the same name here. Instead, we change by prepending "ace_".

int ace_isalnum (ACE_TCHAR c)
 Returns true if the character is an alphanumeric character.
 
int ace_isalpha (ACE_TCHAR c)
 Returns true if the character is an alphabetic character.
 
int ace_isblank (ACE_TCHAR c)
 Returns true if the character is a control character.
 
int ace_isascii (ACE_TCHAR c)
 Returns true if the character is a control character.
 
int ace_iscntrl (ACE_TCHAR c)
 Returns true if the character is a control character.
 
int ace_isdigit (ACE_TCHAR c)
 Returns true if the character is a decimal-digit character.
 
int ace_isgraph (ACE_TCHAR c)
 Returns true if the character is a printable character other than a space.
 
int ace_islower (ACE_TCHAR c)
 Returns true if the character is a lowercase character.
 
int ace_isprint (ACE_TCHAR c)
 Returns true if the character is a printable character.
 
int ace_ispunct (ACE_TCHAR c)
 Returns true if the character is a punctuation character.
 
int ace_isspace (ACE_TCHAR c)
 Returns true if the character is a space character.
 
int ace_isupper (ACE_TCHAR c)
 Returns true if the character is an uppercase character.
 
int ace_isxdigit (ACE_TCHAR c)
 Returns true if the character is a hexadecimal-digit character.
 
int ace_tolower (int c)
 Converts a character to lower case (char version).
 
wint_t ace_towlower (wint_t c)
 Converts a character to lower case (wchar_t version).
 
int ace_toupper (int c)
 Converts a character to upper case (char version).
 
wint_t ace_towupper (wint_t c)
 Converts a character to upper case (wchar_t version).
 
int ace_isctype (int c, ctype_t desc)
 Tests c for the property specified by the desc argument.
 
int ace_iswctype (wint_t c, wctype_t desc)
 Tests c for the property specified by the desc argument.
 
Functions from <cstring>

Included are the functions defined in <cstring> and their <cwchar> equivalents.

Todo:
To be complete, we should add strcoll, and strxfrm.
const voidmemchr (const void *s, int c, size_t len)
 Finds characters in a buffer (const void version).
 
voidmemchr (void *s, int c, size_t len)
 Finds characters in a buffer (void version).
 
int memcmp (const void *t, const void *s, size_t len)
 Compares two buffers.
 
voidmemcpy (void *t, const void *s, size_t len)
 Copies one buffer to another.
 
voidmemmove (void *t, const void *s, size_t len)
 Moves one buffer to another.
 
voidmemset (void *s, int c, size_t len)
 Fills a buffer with a character value.
 
charstrcat (char *s, const char *t)
 Appends a string to another string (char version).
 
wchar_tstrcat (wchar_t *s, const wchar_t *t)
 Appends a string to another string (wchar_t version).
 
const charstrchr (const char *s, int c)
 
const wchar_tstrchr (const wchar_t *s, wchar_t c)
 
charstrchr (char *s, int c)
 Finds the first occurrence of a character in a string (char version).
 
wchar_tstrchr (wchar_t *s, wchar_t c)
 Finds the first occurrence of a character in a string (wchar_t version).
 
int strcmp (const char *s, const char *t)
 Compares two strings (char version).
 
int strcmp (const ACE_WCHAR_T *s, const ACE_WCHAR_T *t)
 Compares two strings (wchar_t version).
 
charstrcpy (char *s, const char *t)
 Copies a string (char version).
 
wchar_tstrcpy (wchar_t *s, const wchar_t *t)
 Copies a string (wchar_t version).
 
size_t strcspn (const char *s, const char *reject)
 
size_t strcspn (const wchar_t *s, const wchar_t *reject)
 
charstrdup (const char *s)
 Returns a malloced duplicated string (char version).
 
wchar_tstrdup (const wchar_t *s)
 Returns a malloced duplicated string (wchar_t version).
 
charstrecpy (char *des, const char *src)
 
wchar_tstrecpy (wchar_t *s, const wchar_t *t)
 
charstrerror (int errnum)
 
charstrsignal (int signum)
 
charstrerror_r (int errnum, char *buf, size_t buflen)
 Finds characters in a buffer (const void version).
 
size_t strlen (const char *s)
 Finds the length of a string (char version).
 
size_t strlen (const ACE_WCHAR_T *s)
 Finds the length of a string (ACE_WCHAR_T version).
 
charstrncat (char *s, const char *t, size_t len)
 Appends part of a string to another string (char version).
 
ACE_WCHAR_Tstrncat (ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
 Appends part of a string to another string (wchar_t version).
 
const charstrnchr (const char *s, int c, size_t len)
 
const ACE_WCHAR_Tstrnchr (const ACE_WCHAR_T *s, ACE_WCHAR_T c, size_t len)
 
charstrnchr (char *s, int c, size_t len)
 Finds the first occurrence of a character in an array (char version).
 
ACE_WCHAR_Tstrnchr (ACE_WCHAR_T *s, ACE_WCHAR_T c, size_t len)
 Finds the first occurrence of a character in an array (ACE_WCHAR_T version).
 
int strncmp (const char *s, const char *t, size_t len)
 Compares two arrays (char version).
 
int strncmp (const ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
 Compares two arrays (wchar_t version).
 
charstrncpy (char *s, const char *t, size_t len)
 Copies an array (char version)
 
ACE_WCHAR_Tstrncpy (ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
 Copies an array (ACE_WCHAR_T version)
 
size_t strnlen (const char *s, size_t maxlen)
 Finds the length of a limited-length string (char version).
 
size_t strnlen (const ACE_WCHAR_T *s, size_t maxlen)
 Finds the length of a limited-length string (ACE_WCHAR_T version).
 
const charstrnstr (const char *s, const char *t, size_t len)
 
const ACE_WCHAR_Tstrnstr (const ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
 
charstrnstr (char *s, const char *t, size_t len)
 Finds the first occurrence of a substring in an array (char version).
 
ACE_WCHAR_Tstrnstr (ACE_WCHAR_T *s, const ACE_WCHAR_T *t, size_t len)
 Finds the first occurrence of a substring in an array (wchar_t version).
 
const charstrpbrk (const char *s1, const char *s2)
 Searches for characters in a string (const char version).
 
const wchar_tstrpbrk (const wchar_t *s1, const wchar_t *s2)
 Searches for characters in a string (const wchar_t version).
 
charstrpbrk (char *s1, const char *s2)
 Searches for characters in a string (char version).
 
wchar_tstrpbrk (wchar_t *s1, const wchar_t *s2)
 Searches for characters in a string (wchar_t version).
 
const charstrrchr (const char *s, int c)
 
const wchar_tstrrchr (const wchar_t *s, wchar_t c)
 
charstrrchr (char *s, int c)
 Finds the last occurrence of a character in a string (char version).
 
wchar_tstrrchr (wchar_t *s, wchar_t c)
 Finds the last occurrence of a character in a string (wchar_t version).
 
charstrsncpy (char *dst, const char *src, size_t maxlen)
 This is a "safe" c string copy function (char version).
 
ACE_WCHAR_Tstrsncpy (ACE_WCHAR_T *dst, const ACE_WCHAR_T *src, size_t maxlen)
 This is a "safe" c string copy function (wchar_t version).
 
size_t strspn (const char *s1, const char *s2)
 
size_t strspn (const wchar_t *s1, const wchar_t *s2)
 
const charstrstr (const char *s, const char *t)
 
const wchar_tstrstr (const wchar_t *s, const wchar_t *t)
 
charstrstr (char *s, const char *t)
 Finds the first occurrence of a substring in a string (char version).
 
wchar_tstrstr (wchar_t *s, const wchar_t *t)
 Finds the first occurrence of a substring in a string (wchar_t version).
 
charstrtok (char *s, const char *tokens)
 Finds the next token in a string (char version).
 
wchar_tstrtok (wchar_t *s, const wchar_t *tokens)
 Finds the next token in a string (wchar_t version).
 
charstrtok_r (char *s, const char *tokens, char **lasts)
 Finds the next token in a string (safe char version).
 
wchar_tstrtok_r (ACE_WCHAR_T *s, const ACE_WCHAR_T *tokens, ACE_WCHAR_T **lasts)
 Finds the next token in a string (wchar_t version).
 

Variables

ACE_TEXT_OSVERSIONINFO win32_versioninfo_
 
HINSTANCE win32_resource_module_
 
int socket_initialized_
 Keeps track of whether we've already initialized WinSock...
 
ACE_thread_t NULL_thread
 
ACE_hthread_t NULL_hthread
 
ACE_thread_key_t NULL_key
 

Non-standard functions

These functions aren't in the standard.

ACE_EXIT_HOOK exit_hook_ = 0
 Function that is called by <ACE_OS::exit>, if non-null.
 
void _exit (int status=0)
 Function that is called by <ACE_OS::exit>, if non-null.
 
void abort ()
 Function that is called by <ACE_OS::exit>, if non-null.
 
int atexit (ACE_EXIT_HOOK func, const char *name=0)
 
int atoi (const char *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
int atoi (const wchar_t *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
long atol (const char *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
long atol (const wchar_t *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
double atof (const char *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
double atof (const wchar_t *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
voidatop (const char *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
voidatop (const wchar_t *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
voidbsearch (const void *key, const void *base, size_t nel, size_t size, ACE_COMPARE_FUNC)
 Function that is called by <ACE_OS::exit>, if non-null.
 
voidcalloc (size_t elements, size_t sizeof_elements)
 Function that is called by <ACE_OS::exit>, if non-null.
 
void exit (int status=0)
 Function that is called by <ACE_OS::exit>, if non-null.
 
void free (void *)
 Function that is called by <ACE_OS::exit>, if non-null.
 
chargetenv (const char *symbol)
 Function that is called by <ACE_OS::exit>, if non-null.
 
wchar_tgetenv (const wchar_t *symbol)
 Function that is called by <ACE_OS::exit>, if non-null.
 
ACE_TCHARgetenvstrings ()
 Function that is called by <ACE_OS::exit>, if non-null.
 
charitoa (int value, char *string, int radix)
 Converts an integer to a string.
 
wchar_titoa (int value, wchar_t *string, int radix)
 Converts an integer to a string.
 
charitoa_emulation (int value, char *string, int radix)
 Emulated itoa - Converts an integer to a string.
 
voidmalloc (size_t)
 Function that is called by <ACE_OS::exit>, if non-null.
 
ACE_HANDLE mkstemp (char *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
ACE_HANDLE mkstemp (wchar_t *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
charmktemp (char *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
wchar_tmktemp (wchar_t *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
int putenv (const char *string)
 Function that is called by <ACE_OS::exit>, if non-null.
 
int putenv (const wchar_t *string)
 Function that is called by <ACE_OS::exit>, if non-null.
 
void qsort (void *base, size_t nel, size_t width, ACE_COMPARE_FUNC)
 Function that is called by <ACE_OS::exit>, if non-null.
 
int setenv (const char *envname, const char *envval, int overwrite)
 Function that is called by <ACE_OS::exit>, if non-null.
 
int unsetenv (const char *name)
 Function that is called by <ACE_OS::exit>, if non-null.
 
int rand ()
 Function that is called by <ACE_OS::exit>, if non-null.
 
int rand_r (unsigned int *seed)
 Function that is called by <ACE_OS::exit>, if non-null.
 
voidrealloc (void *, size_t)
 Function that is called by <ACE_OS::exit>, if non-null.
 
charrealpath (const char *file_name, char *resolved_name)
 Function that is called by <ACE_OS::exit>, if non-null.
 
wchar_trealpath (const wchar_t *file_name, wchar_t *resolved_name)
 Function that is called by <ACE_OS::exit>, if non-null.
 
ACE_EXIT_HOOK set_exit_hook (ACE_EXIT_HOOK hook)
 For use by ACE_Object_Manager only, to register its exit hook..
 
void srand (u_int seed)
 Function that is called by <ACE_OS::exit>, if non-null.
 
ACE_TCHARstrenvdup (const ACE_TCHAR *str)
 Function that is called by <ACE_OS::exit>, if non-null.
 
double strtod (const char *s, char **endptr)
 Converts a string to a double value (char version).
 
double strtod (const wchar_t *s, wchar_t **endptr)
 Converts a string to a double value (wchar_t version).
 
long strtol (const char *s, char **ptr, int base)
 Converts a string to a long value (char version).
 
long strtol (const wchar_t *s, wchar_t **ptr, int base)
 Converts a string to a long value (wchar_t version).
 
unsigned long strtoul (const char *s, char **ptr, int base)
 Converts a string to an unsigned long value (char version).
 
unsigned long strtoul (const wchar_t *s, wchar_t **ptr, int base)
 Converts a string to an unsigned long value (wchar_t version).
 
ACE_INT64 strtoll (const char *s, char **ptr, int base)
 Converts a string to a signed 64 bit int value (char version).
 
ACE_INT64 strtoll (const wchar_t *s, wchar_t **ptr, int base)
 Converts a string to a signed 64 bit int value (wchar_t version).
 
ACE_UINT64 strtoull (const char *s, char **ptr, int base)
 Converts a string to a unsigned 64 bit int value (char version).
 
ACE_UINT64 strtoull (const wchar_t *s, wchar_t **ptr, int base)
 Converts a string to a unsigned 64 bit int value (wchar_t version).
 
int system (const ACE_TCHAR *s)
 Function that is called by <ACE_OS::exit>, if non-null.
 
const chargetprogname ()
 
const chargetprogname_emulation ()
 Function that is called by <ACE_OS::exit>, if non-null.
 
void setprogname (const char *name)
 
void setprogname_emulation (const char *name)
 Function that is called by <ACE_OS::exit>, if non-null.
 

Detailed Description

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

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

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

Typedef Documentation

◆ WChar

Enumeration Type Documentation

◆ ACE_HRTimer_Op

Enumerator
ACE_HRTIMER_START 
ACE_HRTIMER_INCR 
ACE_HRTIMER_STOP 
ACE_HRTIMER_GETTIME 

Function Documentation

◆ _exit()

void ACE_OS::_exit ( int  status = 0)
inline

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

◆ abort()

void ACE_OS::abort ( )
inline

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

◆ accept() [1/2]

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

BSD-style accept (no QoS).

◆ accept() [2/2]

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

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

◆ access() [1/2]

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

◆ access() [2/2]

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

◆ ace_isalnum()

int ACE_OS::ace_isalnum ( ACE_TCHAR  c)
inline

Returns true if the character is an alphanumeric character.

◆ ace_isalpha()

int ACE_OS::ace_isalpha ( ACE_TCHAR  c)
inline

Returns true if the character is an alphabetic character.

◆ ace_isascii()

int ACE_OS::ace_isascii ( ACE_TCHAR  c)
inline

Returns true if the character is a control character.

◆ ace_isblank()

int ACE_OS::ace_isblank ( ACE_TCHAR  c)
inline

Returns true if the character is a control character.

◆ ace_iscntrl()

int ACE_OS::ace_iscntrl ( ACE_TCHAR  c)
inline

Returns true if the character is a control character.

◆ ace_isctype()

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

Tests c for the property specified by the desc argument.

◆ ace_isdigit()

int ACE_OS::ace_isdigit ( ACE_TCHAR  c)
inline

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

◆ ace_isgraph()

int ACE_OS::ace_isgraph ( ACE_TCHAR  c)
inline

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

◆ ace_islower()

int ACE_OS::ace_islower ( ACE_TCHAR  c)
inline

Returns true if the character is a lowercase character.

◆ ace_isprint()

int ACE_OS::ace_isprint ( ACE_TCHAR  c)
inline

Returns true if the character is a printable character.

◆ ace_ispunct()

int ACE_OS::ace_ispunct ( ACE_TCHAR  c)
inline

Returns true if the character is a punctuation character.

◆ ace_isspace()

int ACE_OS::ace_isspace ( ACE_TCHAR  c)
inline

Returns true if the character is a space character.

◆ ace_isupper()

int ACE_OS::ace_isupper ( ACE_TCHAR  c)
inline

Returns true if the character is an uppercase character.

◆ ace_iswctype()

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

Tests c for the property specified by the desc argument.

◆ ace_isxdigit()

int ACE_OS::ace_isxdigit ( ACE_TCHAR  c)
inline

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

◆ ace_tolower()

int ACE_OS::ace_tolower ( int  c)
inline

Converts a character to lower case (char version).

◆ ace_toupper()

int ACE_OS::ace_toupper ( int  c)
inline

Converts a character to upper case (char version).

◆ ace_towlower()

wint_t ACE_OS::ace_towlower ( wint_t  c)
inline

Converts a character to lower case (wchar_t version).

◆ ace_towupper()

wint_t ACE_OS::ace_towupper ( wint_t  c)
inline

Converts a character to upper case (wchar_t version).

◆ alarm()

u_int ACE_OS::alarm ( u_int  secs)
inline

◆ allocation_granularity()

long ACE_OS::allocation_granularity ( )
inline

◆ alphasort()

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

◆ argv_to_string() [1/2]

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

◆ argv_to_string() [2/2]

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

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

◆ asctime()

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

◆ asctime_r()

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

◆ asprintf() [1/2]

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

◆ asprintf() [2/2]

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

◆ atexit()

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

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

◆ atof() [1/2]

double ACE_OS::atof ( const char s)
inline

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

◆ atof() [2/2]

double ACE_OS::atof ( const wchar_t s)
inline

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

◆ atoi() [1/2]

int ACE_OS::atoi ( const char s)
inline

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

◆ atoi() [2/2]

int ACE_OS::atoi ( const wchar_t s)
inline

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

◆ atol() [1/2]

long ACE_OS::atol ( const char s)
inline

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

◆ atol() [2/2]

long ACE_OS::atol ( const wchar_t s)
inline

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

◆ atop() [1/2]

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

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

◆ atop() [2/2]

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

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

◆ bind()

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

◆ bsearch()

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

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

◆ calloc()

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

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

◆ ceil()

template<typename T >
T ACE_OS::ceil ( x)
inline

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

◆ chdir() [1/2]

int ACE_OS::chdir ( const char path)
inline

◆ chdir() [2/2]

int ACE_OS::chdir ( const wchar_t path)
inline

◆ cleanup_tss()

void ACE_OS::cleanup_tss ( const u_int  main_thread)
externprivate

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

◆ clearerr()

void ACE_OS::clearerr ( FILE fp)
inline

◆ clock_gettime()

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

◆ clock_settime()

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

◆ close()

int ACE_OS::close ( ACE_HANDLE  handle)
inline

◆ closedir()

void ACE_OS::closedir ( ACE_DIR d)
inline

◆ closesocket()

int ACE_OS::closesocket ( ACE_HANDLE  s)
inline

Takes care of windows specific requirement to call closesocket.

◆ compile()

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

◆ cond_broadcast()

int ACE_OS::cond_broadcast ( ACE_cond_t cv)
inlineprivate

◆ cond_destroy()

int ACE_OS::cond_destroy ( ACE_cond_t cv)
inlineprivate

◆ cond_init() [1/4]

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

◆ cond_init() [2/4]

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

◆ cond_init() [3/4]

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

◆ cond_init() [4/4]

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

◆ cond_signal()

int ACE_OS::cond_signal ( ACE_cond_t cv)
inlineprivate

◆ cond_timedwait()

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

◆ cond_wait()

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

◆ condattr_destroy()

int ACE_OS::condattr_destroy ( ACE_condattr_t attributes)
inlineprivate

◆ condattr_init()

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

◆ condattr_setclock()

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

◆ condattr_synctype()

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

◆ connect() [1/2]

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

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

◆ connect() [2/2]

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

BSD-style connect (no QoS).

◆ creat()

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

◆ ctime()

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

◆ ctime_r()

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

◆ cuserid() [1/2]

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

◆ cuserid() [2/2]

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

◆ default_win32_security_attributes()

LPSECURITY_ATTRIBUTES ACE_OS::default_win32_security_attributes ( LPSECURITY_ATTRIBUTES  )
inline

Default Win32 Security Attributes definition.

◆ default_win32_security_attributes_r()

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

◆ difftime()

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

◆ dlclose()

int ACE_OS::dlclose ( ACE_SHLIB_HANDLE  handle)
inline

◆ dlerror()

ACE_TCHAR * ACE_OS::dlerror ( )
inline

◆ dlopen()

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

◆ dlsym()

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

◆ dup() [1/2]

ACE_HANDLE ACE_OS::dup ( ACE_HANDLE  handle)
inline

◆ dup() [2/2]

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

◆ dup2()

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

◆ endpwent()

void ACE_OS::endpwent ( )
inline

◆ enum_protocols()

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

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

◆ event_destroy()

int ACE_OS::event_destroy ( ACE_event_t event)
externprivate

◆ event_init() [1/4]

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

◆ event_init() [2/4]

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

◆ event_init() [3/4]

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

◆ event_init() [4/4]

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

◆ event_pulse()

int ACE_OS::event_pulse ( ACE_event_t event)
externprivate

◆ event_reset()

int ACE_OS::event_reset ( ACE_event_t event)
externprivate

◆ event_signal()

int ACE_OS::event_signal ( ACE_event_t event)
externprivate

◆ event_timedwait()

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

◆ event_wait()

int ACE_OS::event_wait ( ACE_event_t event)
inlineprivate

◆ execl()

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

◆ execle()

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

◆ execlp()

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

◆ execv()

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

◆ execve()

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

◆ execvp()

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

◆ exit()

void ACE_OS::exit ( int  status = 0)
extern

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

◆ fattach()

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

◆ fclose()

int ACE_OS::fclose ( FILE fp)
inline

◆ fcntl()

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

◆ fdetach()

int ACE_OS::fdetach ( const char file)
inline

◆ fdopen()

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

◆ fflush()

int ACE_OS::fflush ( FILE fp)
inline

◆ fgetc()

int ACE_OS::fgetc ( FILE fp)
inline

◆ fgetpos()

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

◆ fgets() [1/2]

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

◆ fgets() [2/2]

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

◆ fgetwc()

wint_t ACE_OS::fgetwc ( FILE fp)
inline

◆ fileno()

ACE_HANDLE ACE_OS::fileno ( FILE stream)
inline

◆ filesize() [1/2]

ACE_OFF_T ACE_OS::filesize ( ACE_HANDLE  handle)
inline

◆ filesize() [2/2]

ACE_OFF_T ACE_OS::filesize ( const ACE_TCHAR handle)
inline

◆ flock_adjust_params()

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

◆ flock_destroy()

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

◆ flock_init()

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

◆ flock_rdlock()

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

◆ flock_tryrdlock()

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

◆ flock_trywrlock()

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

◆ flock_unlock()

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

◆ flock_wrlock()

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

◆ floor()

template<typename T >
T ACE_OS::floor ( x)
inline

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

◆ fopen() [1/4]

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

◆ fopen() [2/4]

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

◆ fopen() [3/4]

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

◆ fopen() [4/4]

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

◆ fork() [1/2]

pid_t ACE_OS::fork ( )
inline

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

◆ fork() [2/2]

pid_t ACE_OS::fork ( const ACE_TCHAR program_name)
extern

◆ fork_exec()

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

◆ fprintf() [1/2]

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

◆ fprintf() [2/2]

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

◆ fputc()

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

◆ fputs() [1/2]

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

◆ fputs() [2/2]

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

◆ fread()

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

◆ free()

void ACE_OS::free ( void ptr)
extern

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

◆ freeaddrinfo()

void ACE_OS::freeaddrinfo ( addrinfo result)
inline

◆ freopen()

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

◆ fseek()

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

◆ fsetpos()

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

◆ fstat()

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

◆ fsync()

int ACE_OS::fsync ( ACE_HANDLE  handle)
inline

◆ ftell()

long ACE_OS::ftell ( FILE fp)
inline

◆ ftruncate()

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

◆ fwrite()

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

◆ gai_strerror()

const ACE_TCHAR * ACE_OS::gai_strerror ( int  errcode)
inline

◆ get_win32_resource_module()

HINSTANCE ACE_OS::get_win32_resource_module ( )
inline

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

◆ get_win32_versioninfo()

const ACE_TEXT_OSVERSIONINFO & ACE_OS::get_win32_versioninfo ( )
inline

Return the win32 OSVERSIONINFO structure.

◆ getaddrinfo()

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

◆ getc()

int ACE_OS::getc ( FILE fp)
inline

◆ getcwd() [1/2]

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

◆ getcwd() [2/2]

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

◆ getegid()

gid_t ACE_OS::getegid ( )
inline

◆ getenv() [1/2]

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

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

◆ getenv() [2/2]

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

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

◆ getenvstrings()

ACE_TCHAR * ACE_OS::getenvstrings ( )
extern

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

◆ geteuid()

uid_t ACE_OS::geteuid ( )
inline

◆ getgid()

gid_t ACE_OS::getgid ( )
inline

◆ gethostbyaddr()

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

◆ gethostbyaddr_r()

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

◆ gethostbyname()

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

◆ gethostbyname_r()

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

◆ gethrtime()

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

◆ getipnodebyaddr()

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

◆ getipnodebyname()

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

◆ getmacaddress()

int ACE_OS::getmacaddress ( struct macaddr_node_t node)
extern

Define a structure for use with the netbios routine

Reset the netbios

◆ getmsg()

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

◆ getnameinfo()

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

◆ getopt()

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

◆ getpagesize()

long ACE_OS::getpagesize ( )
inline

◆ getpeername()

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

◆ getpgid()

pid_t ACE_OS::getpgid ( pid_t  pid)
inline

◆ getpid()

pid_t ACE_OS::getpid ( )
inline

◆ getpmsg()

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

◆ getppid()

pid_t ACE_OS::getppid ( )
inline

◆ getprogname()

const char * ACE_OS::getprogname ( )
inline

Get the name of the current program

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

◆ getprogname_emulation()

const char * ACE_OS::getprogname_emulation ( )
extern

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

◆ getprotobyname()

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

◆ getprotobyname_r()

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

◆ getprotobynumber()

struct protoent * ACE_OS::getprotobynumber ( int  proto)
inline

◆ getprotobynumber_r()

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

◆ getpwent()

struct passwd * ACE_OS::getpwent ( )
inline

◆ getpwnam()

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

◆ getpwnam_r()

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

◆ getrlimit()

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

◆ getrusage()

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

◆ getservbyname()

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

◆ getservbyname_r()

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

◆ getsockname()

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

◆ getsockopt()

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

◆ gettimeofday()

ACE_Time_Value ACE_OS::gettimeofday ( )
inline

◆ gettimeofday_()

ACE_Time_Value ACE_OS::gettimeofday_ ( )
inline

◆ getuid()

uid_t ACE_OS::getuid ( )
inline

◆ gmtime()

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

◆ gmtime_r()

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

◆ hostname() [1/2]

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

◆ hostname() [2/2]

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

◆ if_freenameindex()

void ACE_OS::if_freenameindex ( struct if_nameindex ptr)
inline

◆ if_indextoname()

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

◆ if_nameindex()

struct if_nameindex * ACE_OS::if_nameindex ( )
inline

◆ if_nametoindex()

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

◆ inet_addr()

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

◆ inet_aton()

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

◆ inet_ntoa()

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

◆ inet_ntop()

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

◆ inet_pton()

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

◆ ioctl() [1/3]

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

UNIX-style ioctl.

◆ ioctl() [2/3]

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

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

◆ ioctl() [3/3]

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

QoS-enabled ioctl.

◆ isastream()

int ACE_OS::isastream ( ACE_HANDLE  handle)
inline

◆ isatty() [1/2]

int ACE_OS::isatty ( ACE_HANDLE  handle)
inline

◆ isatty() [2/2]

int ACE_OS::isatty ( int  handle)
inline

◆ itoa() [1/2]

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

Converts an integer to a string.

◆ itoa() [2/2]

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

Converts an integer to a string.

◆ itoa_emulation()

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

Emulated itoa - Converts an integer to a string.

◆ join_leaf()

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

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

◆ kill()

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

◆ last_error() [1/2]

int ACE_OS::last_error ( )
inline

◆ last_error() [2/2]

void ACE_OS::last_error ( int  error)
inline

◆ listen()

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

◆ localtime()

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

◆ localtime_r()

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

◆ log2()

double ACE_OS::log2 ( double  x)
inline

This method computes the base-2 logarithm of x.

◆ lseek()

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

◆ lstat() [1/2]

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

◆ lstat() [2/2]

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

◆ lwp_getparams()

int ACE_OS::lwp_getparams ( ACE_Sched_Params sched_params)
externprivate

◆ lwp_setparams()

int ACE_OS::lwp_setparams ( const ACE_Sched_Params sched_params)
externprivate

◆ madvise()

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

◆ malloc()

void * ACE_OS::malloc ( size_t  nbytes)
extern

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

◆ memchr() [1/2]

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

Finds characters in a buffer (const void version).

◆ memchr() [2/2]

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

Finds characters in a buffer (void version).

◆ memcmp()

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

Compares two buffers.

◆ memcpy()

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

Copies one buffer to another.

◆ memmove()

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

Moves one buffer to another.

◆ memset()

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

Fills a buffer with a character value.

◆ mkdir() [1/2]

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

◆ mkdir() [2/2]

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

◆ mkfifo()

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

◆ mkstemp() [1/2]

ACE_HANDLE ACE_OS::mkstemp ( char s)
inline

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

◆ mkstemp() [2/2]

ACE_HANDLE ACE_OS::mkstemp ( wchar_t s)
inline

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

◆ mktemp() [1/2]

char * ACE_OS::mktemp ( char s)
inline

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

◆ mktemp() [2/2]

wchar_t * ACE_OS::mktemp ( wchar_t s)
inline

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

◆ mktime()

time_t ACE_OS::mktime ( struct tm *  timeptr)
extern

◆ mmap()

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

◆ mprotect()

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

◆ msgctl()

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

◆ msgget()

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

◆ msgrcv()

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

◆ msgsnd()

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

◆ msync()

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

◆ munmap()

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

◆ mutex_destroy()

int ACE_OS::mutex_destroy ( ACE_mutex_t m)
externprivate

◆ mutex_init() [1/2]

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

◆ mutex_init() [2/2]

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

◆ mutex_lock() [1/4]

int ACE_OS::mutex_lock ( ACE_mutex_t m)
externprivate

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

◆ mutex_lock() [2/4]

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

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

◆ mutex_lock() [3/4]

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

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

◆ mutex_lock() [4/4]

int ACE_OS::mutex_lock ( ACE_mutex_t m,
int abandoned 
)
externprivate

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

◆ mutex_lock_cleanup()

void ACE_OS::mutex_lock_cleanup ( void mutex)
externprivate

Handle asynchronous thread cancellation cleanup.

◆ mutex_trylock() [1/2]

int ACE_OS::mutex_trylock ( ACE_mutex_t m)
externprivate

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

◆ mutex_trylock() [2/2]

int ACE_OS::mutex_trylock ( ACE_mutex_t m,
int abandoned 
)
externprivate

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

◆ mutex_unlock()

int ACE_OS::mutex_unlock ( ACE_mutex_t m)
externprivate

◆ nanosleep()

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

◆ num_processors()

long ACE_OS::num_processors ( )
extern

Get the number of CPUs configured in the machine.

◆ num_processors_online()

long ACE_OS::num_processors_online ( )
extern

Get the number of CPUs currently online.

◆ open() [1/2]

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

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

◆ open() [2/2]

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

◆ opendir()

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

◆ perror() [1/2]

void ACE_OS::perror ( const char s)
inline

◆ perror() [2/2]

void ACE_OS::perror ( const wchar_t s)
inline

◆ pipe()

int ACE_OS::pipe ( ACE_HANDLE  handles[])
inline

◆ poll() [1/2]

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

◆ poll() [2/2]

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

◆ posix_devctl()

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

◆ pread()

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

◆ printf() [1/2]

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

◆ printf() [2/2]

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

◆ priority_control()

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

Low-level interface to priocntl(2).

◆ pthread_sigmask()

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

◆ putc()

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

◆ putenv() [1/2]

int ACE_OS::putenv ( const char string)
inline

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

◆ putenv() [2/2]

int ACE_OS::putenv ( const wchar_t string)
inline

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

◆ putmsg()

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

◆ putpmsg()

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

◆ puts() [1/2]

int ACE_OS::puts ( const char s)
inline

◆ puts() [2/2]

int ACE_OS::puts ( const wchar_t s)
inline

◆ pwrite()

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

◆ qsort()

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

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

◆ raise()

int ACE_OS::raise ( const int  signum)
inline

◆ rand()

int ACE_OS::rand ( )
inline

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

◆ rand_r()

int ACE_OS::rand_r ( unsigned int seed)
inline

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

◆ read() [1/2]

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

◆ read() [2/2]

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

◆ read_n()

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

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

◆ readdir()

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

◆ readlink()

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

◆ readv()

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

◆ realloc()

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

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

◆ realpath() [1/2]

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

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

◆ realpath() [2/2]

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

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

◆ recursive_mutex_cond_relock()

void ACE_OS::recursive_mutex_cond_relock ( ACE_recursive_thread_mutex_t m,
ACE_recursive_mutex_state state 
)
inlineprivate

◆ recursive_mutex_cond_unlock()

int ACE_OS::recursive_mutex_cond_unlock ( ACE_recursive_thread_mutex_t m,
ACE_recursive_mutex_state state 
)
inlineprivate

◆ recursive_mutex_destroy()

int ACE_OS::recursive_mutex_destroy ( ACE_recursive_thread_mutex_t m)
inlineprivate

◆ recursive_mutex_init()

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

◆ recursive_mutex_lock() [1/3]

int ACE_OS::recursive_mutex_lock ( ACE_recursive_thread_mutex_t m)
inlineprivate

◆ recursive_mutex_lock() [2/3]

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

◆ recursive_mutex_lock() [3/3]

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

◆ recursive_mutex_trylock()

int ACE_OS::recursive_mutex_trylock ( ACE_recursive_thread_mutex_t m)
inlineprivate

◆ recursive_mutex_unlock()

int ACE_OS::recursive_mutex_unlock ( ACE_recursive_thread_mutex_t m)
inlineprivate

◆ recv()

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

◆ recvfrom() [1/2]

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

◆ recvfrom() [2/2]

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

◆ recvmsg()

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

◆ recvv()

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

◆ rename() [1/2]

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

◆ rename() [2/2]

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

◆ rewind()

void ACE_OS::rewind ( FILE fp)
inline

◆ rewinddir()

void ACE_OS::rewinddir ( ACE_DIR d)
inline

◆ rmdir() [1/2]

int ACE_OS::rmdir ( const char path)
inline

◆ rmdir() [2/2]

int ACE_OS::rmdir ( const wchar_t path)
inline

◆ rw_rdlock()

int ACE_OS::rw_rdlock ( ACE_rwlock_t rw)
inlineprivate

◆ rw_tryrdlock()

int ACE_OS::rw_tryrdlock ( ACE_rwlock_t rw)
inlineprivate

◆ rw_trywrlock()

int ACE_OS::rw_trywrlock ( ACE_rwlock_t rw)
inlineprivate

◆ rw_trywrlock_upgrade()

int ACE_OS::rw_trywrlock_upgrade ( ACE_rwlock_t rw)
inlineprivate

◆ rw_unlock()

int ACE_OS::rw_unlock ( ACE_rwlock_t rw)
inlineprivate

◆ rw_wrlock()

int ACE_OS::rw_wrlock ( ACE_rwlock_t rw)
inlineprivate

◆ rwlock_destroy()

int ACE_OS::rwlock_destroy ( ACE_rwlock_t rw)
inlineprivate

◆ rwlock_init()

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

◆ sbrk()

void * ACE_OS::sbrk ( intptr_t  brk)
inline

◆ scandir()

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

◆ scandir_emulation()

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

◆ sched_params()

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

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

◆ scheduling_class()

int ACE_OS::scheduling_class ( const char class_name,
ACE_id_t  
)
externprivate

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

◆ seekdir()

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

◆ select() [1/2]

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

◆ select() [2/2]

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

◆ sema_avoid_unlink()

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

◆ sema_destroy()

int ACE_OS::sema_destroy ( ACE_sema_t s)
inlineprivate

◆ sema_init() [1/4]

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

◆ sema_init() [2/4]

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

◆ sema_init() [3/4]

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

◆ sema_init() [4/4]

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

◆ sema_post() [1/2]

int ACE_OS::sema_post ( ACE_sema_t s)
inlineprivate

◆ sema_post() [2/2]

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

◆ sema_trywait()

int ACE_OS::sema_trywait ( ACE_sema_t s)
inlineprivate

◆ sema_unlink()

int ACE_OS::sema_unlink ( const char name)
inlineprivate

◆ sema_wait() [1/3]

int ACE_OS::sema_wait ( ACE_sema_t s)
inlineprivate

◆ sema_wait() [2/3]

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

◆ sema_wait() [3/3]

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

◆ semctl()

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

◆ semget()

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

◆ semop()

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

◆ send()

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

◆ send_partial_i()

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

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

◆ sendfile()

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

Wrapper for sendfile to transfer data between file descriptor.

◆ sendmsg()

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

◆ sendto() [1/2]

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

◆ sendto() [2/2]

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

◆ sendv()

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

◆ sendv_partial_i()

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

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

◆ set_errno_to_last_error()

int ACE_OS::set_errno_to_last_error ( )
inline

◆ set_errno_to_wsa_last_error()

int ACE_OS::set_errno_to_wsa_last_error ( )
inline

◆ set_exit_hook()

ACE_EXIT_HOOK ACE_OS::set_exit_hook ( ACE_EXIT_HOOK  hook)
inline

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

◆ set_scheduling_params()

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

Friendly interface to priocntl(2).

◆ set_win32_resource_module()

void ACE_OS::set_win32_resource_module ( HINSTANCE  )
inline

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

◆ setegid()

int ACE_OS::setegid ( gid_t  gid)
inline

◆ setenv()

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

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

◆ seteuid()

int ACE_OS::seteuid ( uid_t  uid)
inline

◆ setgid()

int ACE_OS::setgid ( gid_t  gid)
inline

◆ setpgid()

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

◆ setprogname()

void ACE_OS::setprogname ( const char name)
inline

Set the name of the current program

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

◆ setprogname_emulation()

void ACE_OS::setprogname_emulation ( const char name)
extern

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

◆ setpwent()

void ACE_OS::setpwent ( )
inline

◆ setregid()

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

◆ setreuid()

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

◆ setrlimit()

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

◆ setsid()

pid_t ACE_OS::setsid ( )
inline

◆ setsockopt()

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

Manipulate the options associated with a socket.

◆ setuid()

int ACE_OS::setuid ( uid_t  uid)
inline

◆ shm_open()

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

◆ shm_unlink()

int ACE_OS::shm_unlink ( const ACE_TCHAR path)
inline

◆ shmat()

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

◆ shmctl()

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

◆ shmdt()

int ACE_OS::shmdt ( const void shmaddr)
inline

◆ shmget()

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

◆ shutdown()

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

◆ sigaction()

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

◆ sigaddset()

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

◆ sigdelset()

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

◆ sigemptyset()

int ACE_OS::sigemptyset ( sigset_t s)
inline

◆ sigfillset()

int ACE_OS::sigfillset ( sigset_t s)
inline

◆ sigismember()

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

◆ signal()

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

◆ sigprocmask()

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

◆ sigsuspend()

int ACE_OS::sigsuspend ( const sigset_t s)
inline

◆ sigtimedwait()

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

◆ sigwait()

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

◆ sigwaitinfo()

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

◆ sleep() [1/2]

int ACE_OS::sleep ( const ACE_Time_Value tv)
inline

◆ sleep() [2/2]

int ACE_OS::sleep ( u_int  seconds)
inline

◆ snprintf() [1/2]

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

◆ snprintf() [2/2]

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

◆ socket() [1/2]

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

Create a BSD-style socket (no QoS).

◆ socket() [2/2]

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

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

◆ socket_fini()

int ACE_OS::socket_fini ( )
extern

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

◆ socket_init()

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

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

◆ socketpair()

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

◆ sprintf() [1/2]

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

◆ sprintf() [2/2]

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

◆ srand()

void ACE_OS::srand ( u_int  seed)
inline

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

◆ stat() [1/2]

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

◆ stat() [2/2]

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

◆ step()

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

◆ strcasecmp() [1/2]

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

Compares two strings (case insensitive const char version).

◆ strcasecmp() [2/2]

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

Compares two strings (case insensitive const wchar_t version).

◆ strcat() [1/2]

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

Appends a string to another string (char version).

◆ strcat() [2/2]

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

Appends a string to another string (wchar_t version).

◆ strchr() [1/4]

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

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

◆ strchr() [2/4]

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

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

◆ strchr() [3/4]

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

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

◆ strchr() [4/4]

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

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

◆ strcmp() [1/2]

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

Compares two strings (wchar_t version).

◆ strcmp() [2/2]

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

Compares two strings (char version).

◆ strcpy() [1/2]

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

Copies a string (char version).

◆ strcpy() [2/2]

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

Copies a string (wchar_t version).

◆ strcspn() [1/2]

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

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

◆ strcspn() [2/2]

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

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

◆ strdup() [1/2]

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

Returns a malloced duplicated string (char version).

◆ strdup() [2/2]

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

Returns a malloced duplicated string (wchar_t version).

◆ strecpy() [1/2]

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

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

◆ strecpy() [2/2]

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

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

◆ strenvdup()

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

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

◆ strerror()

char * ACE_OS::strerror ( int  errnum)
extern

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

◆ strerror_r()

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

Finds characters in a buffer (const void version).

◆ strftime()

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

◆ string_to_argv()

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

◆ strlen() [1/2]

size_t ACE_OS::strlen ( const ACE_WCHAR_T s)
inline

Finds the length of a string (ACE_WCHAR_T version).

◆ strlen() [2/2]

size_t ACE_OS::strlen ( const char s)
inline

Finds the length of a string (char version).

◆ strncasecmp() [1/2]

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

Compares two arrays (case insensitive const char version).

◆ strncasecmp() [2/2]

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

Compares two arrays (case insensitive const wchar_t version).

◆ strncat() [1/2]

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

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

◆ strncat() [2/2]

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

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

◆ strnchr() [1/4]

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

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

◆ strnchr() [2/4]

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

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

◆ strnchr() [3/4]

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

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

◆ strnchr() [4/4]

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

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

◆ strncmp() [1/2]

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

Compares two arrays (wchar_t version).

◆ strncmp() [2/2]

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

Compares two arrays (char version).

◆ strncpy() [1/2]

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

Copies an array (ACE_WCHAR_T version)

◆ strncpy() [2/2]

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

Copies an array (char version)

◆ strnlen() [1/2]

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

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

Parameters
sThe character string to find the length of.
maxlenThe maximum number of characters that will be scanned for the terminating nul character.
Returns
The length of
  • s, if the terminating nul character is located, else
  • maxlen.

◆ strnlen() [2/2]

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

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

Parameters
sThe character string to find the length of.
maxlenThe maximum number of characters that will be scanned for the terminating nul character.
Returns
The length of
  • s, if the terminating nul character is located, else
  • maxlen.

◆ strnstr() [1/4]

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

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

◆ strnstr() [2/4]

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

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

◆ strnstr() [3/4]

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

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

◆ strnstr() [4/4]

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

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

◆ strpbrk() [1/4]

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

Searches for characters in a string (char version).

◆ strpbrk() [2/4]

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

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

◆ strpbrk() [3/4]

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

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

◆ strpbrk() [4/4]

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

Searches for characters in a string (wchar_t version).

◆ strptime()

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

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

◆ strrchr() [1/4]

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

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

◆ strrchr() [2/4]

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

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

◆ strrchr() [3/4]

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

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

◆ strrchr() [4/4]

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

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

◆ strsignal()

char * ACE_OS::strsignal ( int  signum)
extern

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

◆ strsncpy() [1/2]

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

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

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

◆ strsncpy() [2/2]

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

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

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

◆ strspn() [1/2]

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

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

◆ strspn() [2/2]

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

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

◆ strstr() [1/4]

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

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

◆ strstr() [2/4]

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

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

◆ strstr() [3/4]

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

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

◆ strstr() [4/4]

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

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

◆ strtod() [1/2]

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

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

◆ strtod() [2/2]

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

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

◆ strtok() [1/2]

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

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

◆ strtok() [2/2]

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

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

◆ strtok_r() [1/2]

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

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

◆ strtok_r() [2/2]

char * ACE_OS::strtok_r ( char s,
const char tokens,
char **  lasts 
)
inline

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

◆ strtol() [1/2]

long ACE_OS::strtol ( const char s,
char **  ptr,
int  base 
)
inline

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

◆ strtol() [2/2]

long ACE_OS::strtol ( const wchar_t s,
wchar_t **  ptr,
int  base 
)
inline

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

◆ strtoll() [1/2]

ACE_INT64 ACE_OS::strtoll ( const char s,
char **  ptr,
int  base 
)
inline

Converts a string to a signed 64 bit int value (char version).

◆ strtoll() [2/2]

ACE_INT64 ACE_OS::strtoll ( const wchar_t s,
wchar_t **  ptr,
int  base 
)
inline

Converts a string to a signed 64 bit int value (wchar_t version).

◆ strtoul() [1/2]

unsigned long ACE_OS::strtoul ( const char s,
char **  ptr,
int  base 
)
inline

Converts a string to an unsigned long value (char version).

◆ strtoul() [2/2]

unsigned long ACE_OS::strtoul ( const wchar_t s,
wchar_t **  ptr,
int  base 
)
inline

Converts a string to an unsigned long value (wchar_t version).

◆ strtoull() [1/2]

ACE_UINT64 ACE_OS::strtoull ( const char s,
char **  ptr,
int  base 
)
inline

Converts a string to a unsigned 64 bit int value (char version).

◆ strtoull() [2/2]

ACE_UINT64 ACE_OS::strtoull ( const wchar_t s,
wchar_t **  ptr,
int  base 
)
inline

Converts a string to a unsigned 64 bit int value (wchar_t version).

◆ swab()

void ACE_OS::swab ( const void src,
void dest,
ssize_t  n 
)
inline

◆ sysconf()

long ACE_OS::sysconf ( int  name)
inline

◆ sysinfo()

long ACE_OS::sysinfo ( int  cmd,
char buf,
long  count 
)
inline

◆ system()

int ACE_OS::system ( const ACE_TCHAR s)
inline

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

◆ t_accept()

int ACE_OS::t_accept ( ACE_HANDLE  fildes,
ACE_HANDLE  resfd,
struct t_call call 
)
inline

◆ t_alloc()

char * ACE_OS::t_alloc ( ACE_HANDLE  fildes,
int  struct_type,
int  fields 
)
inline

◆ t_bind()

int ACE_OS::t_bind ( ACE_HANDLE  fildes,
ACE_TBIND req,
ACE_TBIND ret 
)
inline

◆ t_close()

int ACE_OS::t_close ( ACE_HANDLE  fildes)
inline

◆ t_connect()

int ACE_OS::t_connect ( ACE_HANDLE  fildes,
struct t_call sndcall,
struct t_call rcvcall 
)
inline

◆ t_error()

void ACE_OS::t_error ( const char errmsg)
inline

◆ t_free()

int ACE_OS::t_free ( char ptr,
int  struct_type 
)
inline

◆ t_getinfo()

int ACE_OS::t_getinfo ( ACE_HANDLE  fildes,
struct t_info info 
)
inline

◆ t_getname()

int ACE_OS::t_getname ( ACE_HANDLE  fildes,
struct netbuf namep,
int  type 
)
inline

◆ t_getstate()

int ACE_OS::t_getstate ( ACE_HANDLE  fildes)
inline

◆ t_listen()

int ACE_OS::t_listen ( ACE_HANDLE  fildes,
struct t_call call 
)
inline

◆ t_look()

int ACE_OS::t_look ( ACE_HANDLE  fildes)
inline

◆ t_open()

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

◆ t_optmgmt()

int ACE_OS::t_optmgmt ( ACE_HANDLE  handle,
ACE_TOPTMGMT req,
ACE_TOPTMGMT ret 
)
inline

◆ t_rcv()

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

◆ t_rcvdis()

int ACE_OS::t_rcvdis ( ACE_HANDLE  fildes,
struct t_discon discon 
)
inline

◆ t_rcvrel()

int ACE_OS::t_rcvrel ( ACE_HANDLE  fildes)
inline

◆ t_rcvudata()

int ACE_OS::t_rcvudata ( ACE_HANDLE  fildes,
struct t_unitdata unitdata,
int flags 
)
inline

◆ t_rcvuderr()

int ACE_OS::t_rcvuderr ( ACE_HANDLE  fildes,
struct t_uderr uderr 
)
inline

◆ t_snd()

int ACE_OS::t_snd ( ACE_HANDLE  fildes,
const char buf,
unsigned int  nbytes,
int  flags 
)
inline

◆ t_snddis()

int ACE_OS::t_snddis ( ACE_HANDLE  fildes,
struct t_call call 
)
inline

◆ t_sndrel()

int ACE_OS::t_sndrel ( ACE_HANDLE  fildes)
inline

◆ t_sync()

int ACE_OS::t_sync ( ACE_HANDLE  fildes)
inline

◆ t_unbind()

int ACE_OS::t_unbind ( ACE_HANDLE  fildes)
inline

◆ telldir()

long ACE_OS::telldir ( ACE_DIR d)
inline

◆ tempnam() [1/2]

char * ACE_OS::tempnam ( const char dir = 0,
const char pfx = 0 
)
inline

◆ tempnam() [2/2]

wchar_t * ACE_OS::tempnam ( const wchar_t dir,
const wchar_t pfx = 0 
)
inline

◆ thr_cancel()

int ACE_OS::thr_cancel ( ACE_thread_t  t_id)
inlineprivate

◆ thr_cmp()

int ACE_OS::thr_cmp ( ACE_hthread_t  t1,
ACE_hthread_t  t2 
)
inlineprivate

◆ thr_continue()

int ACE_OS::thr_continue ( ACE_hthread_t  target_thread)
inlineprivate

◆ thr_create()

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

Creates a new thread having flags attributes and running func with args (if thread_adapter is non-0 then func and args are ignored and are obtained from thread_adapter). thr_id and t_handle are set to the thread's ID and handle (?), respectively. The thread runs at priority priority (see below).

The flags are a bitwise-OR of the following: = BEGIN<INDENT> THR_CANCEL_DISABLE, THR_CANCEL_ENABLE, THR_CANCEL_DEFERRED, THR_CANCEL_ASYNCHRONOUS, THR_BOUND, THR_NEW_LWP, THR_DETACHED, THR_SUSPENDED, THR_DAEMON, THR_JOINABLE, THR_SCHED_FIFO, THR_SCHED_RR, THR_SCHED_DEFAULT, THR_EXPLICIT_SCHED, THR_SCOPE_SYSTEM, THR_SCOPE_PROCESS = END<INDENT>

By default, or if priority is set to ACE_DEFAULT_THREAD_PRIORITY, an "appropriate" priority value for the given scheduling policy (specified in flags, e.g., THR_SCHED_DEFAULT) is used. This value is calculated dynamically, and is the median value between the minimum and maximum priority values for the given policy. If an explicit value is given, it is used. Note that actual priority values are EXTREMEMLY implementation-dependent, and are probably best avoided.

Note that thread_adapter is always deleted by thr_create, therefore it must be allocated with global operator new.

At the moment for thr_name a valid string is passed then this will be used on VxWorks to set the task name. If we just pass a pointer the name of the task is returned

◆ thr_equal()

int ACE_OS::thr_equal ( ACE_thread_t  t1,
ACE_thread_t  t2 
)
inlineprivate

◆ thr_exit()

void ACE_OS::thr_exit ( ACE_THR_FUNC_RETURN  status = 0)
externprivate

◆ thr_get_affinity()

int ACE_OS::thr_get_affinity ( ACE_hthread_t  thr_id,
size_t  cpu_set_size,
cpu_set_t cpu_mask 
)
externprivate

Get the thread affinity

Parameters
thr_idFor NPTL-threads, when ACE_HAS_PTHREAD_SETAFFINITY_NP defined, this is the thread-id. For linux-threads, when ACE_HAS_SCHED_SETAFFINITY defined, it expects a process-id. Since for linux-threads a thread is seen as a process, it does the job.
cpu_set_sizeThe size of the cpu_mask, in bytes.
cpu_maskIs a bitmask of CPUs to bind to, e.g value 1 binds the thread to the "CPU 0", etc

◆ thr_getconcurrency()

int ACE_OS::thr_getconcurrency ( )
inlineprivate

◆ thr_getprio() [1/2]

int ACE_OS::thr_getprio ( ACE_hthread_t  id,
int priority 
)
inlineprivate

◆ thr_getprio() [2/2]

int ACE_OS::thr_getprio ( ACE_hthread_t  id,
int priority,
int policy 
)
inlineprivate

◆ thr_getspecific()

int ACE_OS::thr_getspecific ( ACE_thread_key_t  key,
void **  data 
)
inlineprivate

◆ thr_gettid() [1/2]

pid_t ACE_OS::thr_gettid ( )
inlineprivate

For systems that support it (Only Linux as of writing), this is a wrapper for pid_t gettid().

It returns the system-wide thread id (TID) for the current thread. These are similar to PIDs and, for x86 Linux at least, are much shorter than what is returned from thr_self(), which is an address.

For older Linux (pre 2.4.11) and other systems that don't have gettid(), this uses ACE_NOTSUP_RETURN (-1).

◆ thr_gettid() [2/2]

ssize_t ACE_OS::thr_gettid ( char  buffer[],
size_t  buffer_length 
)
inlineprivate

Puts the string representation of pid_t thr_gettid() into the buffer and returns number of bytes added.

◆ thr_id()

ssize_t ACE_OS::thr_id ( char  buffer[],
size_t  buffer_length 
)
inlineprivate

Stores a string version of the current thread id into buffer and returns the size of this thread id in bytes.

◆ thr_join() [1/2]

int ACE_OS::thr_join ( ACE_hthread_t  waiter_id,
ACE_THR_FUNC_RETURN status 
)
inlineprivate

◆ thr_join() [2/2]

int ACE_OS::thr_join ( ACE_thread_t  waiter_id,
ACE_thread_t thr_id,
ACE_THR_FUNC_RETURN status 
)
inlineprivate

◆ thr_key_detach()

int ACE_OS::thr_key_detach ( ACE_thread_key_t  key)
externprivate

◆ thr_key_used()

int ACE_OS::thr_key_used ( ACE_thread_key_t  key)
externprivate

◆ thr_keycreate()

int ACE_OS::thr_keycreate ( ACE_thread_key_t key,
ACE_THR_DEST  dest 
)
externprivate

◆ thr_keyfree()

int ACE_OS::thr_keyfree ( ACE_thread_key_t  key)
externprivate

◆ thr_kill()

int ACE_OS::thr_kill ( ACE_thread_t  thr_id,
int  signum 
)
inlineprivate

◆ thr_min_stack()

size_t ACE_OS::thr_min_stack ( )
inlineprivate

◆ thr_name()

const char * ACE_OS::thr_name ( )
inlineprivate

◆ thr_self() [1/2]

ACE_thread_t ACE_OS::thr_self ( )
inlineprivate

◆ thr_self() [2/2]

void ACE_OS::thr_self ( ACE_hthread_t self)
inlineprivate

◆ thr_set_affinity()

int ACE_OS::thr_set_affinity ( ACE_hthread_t  thr_id,
size_t  cpu_set_size,
const cpu_set_t cpu_mask 
)
externprivate

Set the thread affinity

Parameters
thr_idFor NPTL-threads, when ACE_HAS_PTHREAD_SETAFFINITY_NP defined, this is the thread-id. For linux-threads, when ACE_HAS_SCHED_SETAFFINITY defined, it expects a process-id. Since for linux-threads a thread is seen as a process, it does the job.
cpu_set_sizeThe size of the cpu_mask, in bytes.
cpu_maskIs a bitmask of CPUs to bind to, e.g value 1 binds the thread to the "CPU 0", etc

◆ thr_setcancelstate()

int ACE_OS::thr_setcancelstate ( int  new_state,
int old_state 
)
inlineprivate

State is THR_CANCEL_ENABLE or THR_CANCEL_DISABLE.

◆ thr_setcanceltype()

int ACE_OS::thr_setcanceltype ( int  new_type,
int old_type 
)
inlineprivate

Type is THR_CANCEL_DEFERRED or THR_CANCEL_ASYNCHRONOUS.

◆ thr_setconcurrency()

int ACE_OS::thr_setconcurrency ( int  hint)
inlineprivate

◆ thr_setprio() [1/2]

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

◆ thr_setprio() [2/2]

int ACE_OS::thr_setprio ( const ACE_Sched_Priority  prio)
externprivate

◆ thr_setspecific()

int ACE_OS::thr_setspecific ( ACE_thread_key_t  key,
void data 
)
externprivate

◆ thr_sigsetmask()

int ACE_OS::thr_sigsetmask ( int  how,
const sigset_t nsm,
sigset_t osm 
)
inlineprivate

◆ thr_suspend()

int ACE_OS::thr_suspend ( ACE_hthread_t  target_thread)
inlineprivate

◆ thr_testcancel()

void ACE_OS::thr_testcancel ( )
inlineprivate

◆ thr_yield()

void ACE_OS::thr_yield ( )
inlineprivate

◆ thread_mutex_destroy()

int ACE_OS::thread_mutex_destroy ( ACE_thread_mutex_t m)
inlineprivate

◆ thread_mutex_init() [1/2]

int ACE_OS::thread_mutex_init ( ACE_thread_mutex_t m,
int  lock_type,
const wchar_t name,
ACE_mutexattr_t arg = 0 
)
inlineprivate

◆ thread_mutex_init() [2/2]

int ACE_OS::thread_mutex_init ( ACE_thread_mutex_t m,
int  lock_type = 0,
const char name = 0,
ACE_mutexattr_t arg = 0 
)
inlineprivate

◆ thread_mutex_lock() [1/3]

int ACE_OS::thread_mutex_lock ( ACE_thread_mutex_t m)
inlineprivate

◆ thread_mutex_lock() [2/3]

int ACE_OS::thread_mutex_lock ( ACE_thread_mutex_t m,
const ACE_Time_Value timeout 
)
inlineprivate

◆ thread_mutex_lock() [3/3]

int ACE_OS::thread_mutex_lock ( ACE_thread_mutex_t m,
const ACE_Time_Value timeout 
)
inlineprivate

◆ thread_mutex_trylock()

int ACE_OS::thread_mutex_trylock ( ACE_thread_mutex_t m)
inlineprivate

◆ thread_mutex_unlock()

int ACE_OS::thread_mutex_unlock ( ACE_thread_mutex_t m)
inlineprivate

◆ time()

time_t ACE_OS::time ( time_t tloc = 0)
inline

◆ timezone()

long ACE_OS::timezone ( )
inline

◆ truncate()

int ACE_OS::truncate ( const ACE_TCHAR filename,
ACE_OFF_T  length 
)
inline

◆ tzset()

void ACE_OS::tzset ( )
inline

◆ ualarm() [1/2]

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

◆ ualarm() [2/2]

useconds_t ACE_OS::ualarm ( useconds_t  usecs,
useconds_t  interval = 0 
)
inline

◆ umask()

mode_t ACE_OS::umask ( mode_t  cmask)
inline

◆ uname()

int ACE_OS::uname ( ACE_utsname name)
extern

◆ ungetc()

int ACE_OS::ungetc ( int  c,
FILE fp 
)
inline

◆ ungetwc()

wint_t ACE_OS::ungetwc ( wint_t  c,
FILE fp 
)
inline

◆ unique_name()

void ACE_OS::unique_name ( const void object,
char name,
size_t  length 
)
externprivate

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

◆ unlink() [1/2]

int ACE_OS::unlink ( const char path)
inline

◆ unlink() [2/2]

int ACE_OS::unlink ( const wchar_t path)
inline

◆ unsetenv()

int ACE_OS::unsetenv ( const char name)
inline

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

◆ vasprintf() [1/2]

int ACE_OS::vasprintf ( char **  bufp,
const char format,
va_list  argptr 
)
inline

◆ vasprintf() [2/2]

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

◆ vasprintf_emulation()

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

◆ vaswprintf_emulation()

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

◆ vfprintf() [1/2]

int ACE_OS::vfprintf ( FILE fp,
const char format,
va_list  argptr 
)
inline

◆ vfprintf() [2/2]

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

◆ vprintf() [1/2]

int ACE_OS::vprintf ( const char format,
va_list  argptr 
)
inline

◆ vprintf() [2/2]

int ACE_OS::vprintf ( const wchar_t format,
va_list  argptr 
)
inline

◆ vsnprintf() [1/2]

int ACE_OS::vsnprintf ( char buffer,
size_t  maxlen,
const char format,
va_list  argptr 
)
inline

◆ vsnprintf() [2/2]

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

◆ vsprintf() [1/2]

int ACE_OS::vsprintf ( char buffer,
const char format,
va_list  argptr 
)
inline

◆ vsprintf() [2/2]

int ACE_OS::vsprintf ( wchar_t buffer,
const wchar_t format,
va_list  argptr 
)
inline

◆ wait() [1/2]

pid_t ACE_OS::wait ( int status = 0)
inline

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

◆ wait() [2/2]

pid_t ACE_OS::wait ( pid_t  pid,
ACE_exitcode status,
int  wait_options = 0,
ACE_HANDLE  handle = 0 
)
inline

Calls ::WaitForSingleObject on Win32 and ACE::waitpid () otherwise. Returns the passed in pid_t on success and -1 on failure. On Win32, pid is ignored if the handle is not equal to 0. Passing the process handle is prefer on Win32 because using pid to wait on the project doesn't always work correctly if the waited process has already terminated.

◆ waitpid()

pid_t ACE_OS::waitpid ( pid_t  pid,
ACE_exitcode status = 0,
int  wait_options = 0,
ACE_HANDLE  handle = 0 
)
inline

Calls waitpid on UNIX/POSIX platforms Does not work on VxWorks 5.5.x. On Win32, pid is ignored if the handle is not equal to 0. Passing the process handle is prefer on Win32 because using pid to wait on the project doesn't always work correctly if the waited process has already terminated.

◆ write() [1/2]

ssize_t ACE_OS::write ( ACE_HANDLE  handle,
const void buf,
size_t  nbyte 
)
inline

◆ write() [2/2]

ssize_t ACE_OS::write ( ACE_HANDLE  handle,
const void buf,
size_t  nbyte,
ACE_OVERLAPPED overlapped 
)
inline

◆ write_n()

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

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

◆ writev()

ssize_t ACE_OS::writev ( ACE_HANDLE  handle,
const iovec iov,
int  iovcnt 
)
inline

◆ wscmp()

int ACE_OS::wscmp ( const WChar s,
const WChar t 
)
inline

◆ wscpy()

ACE_OS::WChar * ACE_OS::wscpy ( WChar dest,
const WChar src 
)
inline

◆ wslen()

u_int ACE_OS::wslen ( const WChar s)
inline

◆ wsncmp()

int ACE_OS::wsncmp ( const WChar s,
const WChar t,
size_t  len 
)
inline

Variable Documentation

◆ exit_hook_

ACE_EXIT_HOOK ACE_OS::exit_hook_ = 0
extern

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

◆ NULL_hthread

ACE_hthread_t ACE_OS::NULL_hthread
externprivate

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

◆ NULL_key

ACE_thread_key_t ACE_OS::NULL_key
externprivate

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

◆ NULL_thread

ACE_thread_t ACE_OS::NULL_thread
externprivate

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

◆ socket_initialized_

int ACE_OS::socket_initialized_
extern

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

◆ win32_resource_module_

HINSTANCE ACE_OS::win32_resource_module_
extern

◆ win32_versioninfo_

ACE_TEXT_OSVERSIONINFO ACE_OS::win32_versioninfo_
extern