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

# ACE_OS Member List

This is the complete list of members for ACE_OS, including all inherited members.

- _exit(int status = 0) `[static]`
- abort(void) `[static]`
- accept(ACE_HANDLE handle, struct sockaddr *addr, int *addrlen) `[static]`
- accept(ACE_HANDLE handle, struct sockaddr *addr, int *addrlen, const ACE_Accept_QoS_Params &qos_params) `[static]`
- access(const char *path, int amode) `[static]`
- access(const wchar_t *path, int amode) `[static]`
- ACE_CLASS_IS_NAMESPACE(ACE_OS) `[private]`
- ACE_HRTIMER_GETTIME enum value
- ACE_HRTIMER_INCR enum value
- ACE_HRTimer_Op enum name
- ACE_HRTIMER_START enum value
- ACE_HRTIMER_STOP enum value
- ace_isprint(const ACE_TCHAR c) `[static]`
- ace_isspace(const ACE_TCHAR c) `[static]`
- ACE_OS_Object_Manager class `[friend]`
- ACE_Timeout_Manager class `[friend]`
- adjust_flock_params(ACE_OS::ace_flock_t *lock, short whence, off_t &start, off_t &len) `[static]`
- alarm(u_int secs) `[static]`
- alarm_i(u_int secs) `[private, static]`
- allocation_granularity(void) `[static]`
- argv_to_string(ACE_TCHAR **argv, ACE_TCHAR *&buf, int substitute_env_args = 1) `[static]`
- asctime(const struct tm *tm) `[static]`
- asctime_r(const struct tm *tm, char *buf, int buflen) `[static]`
- atexit(ACE_EXIT_HOOK func) `[static]`
- atoi(const char *s) `[static]`
- atoi(const wchar_t *s) `[static]`
- bind(ACE_HANDLE s, struct sockaddr *name, int namelen) `[static]`
- bsearch(const void *key, const void *base, size_t nel, size_t size, ACE_COMPARE_FUNC) `[static]`
- calloc(size_t elements, size_t sizeof_elements) `[static]`
- ceil(double x) `[static]`
- chdir(const char *path) `[static]`
- chdir(const wchar_t *path) `[static]`
- cleanup_tss(const u_int main_thread) `[static]`
- clock_gettime(clockid_t, struct timespec *) `[static]`
- close(ACE_HANDLE handle) `[static]`
- closedir(ACE_DIR *) `[static]`
- closesocket(ACE_HANDLE s) `[static]`
- compile(const char *instring, char *expbuf, char *endbuf) `[static]`
- cond_broadcast(ACE_cond_t *cv) `[static]`
- cond_destroy(ACE_cond_t *cv) `[static]`
- cond_init(ACE_cond_t *cv, short type = ACE_DEFAULT_SYNCH_TYPE, const char *name = 0, void *arg = 0) `[static]`
- cond_init(ACE_cond_t *cv, ACE_condattr_t &attributes, const char *name = 0, void *arg = 0) `[static]`
- cond_init(ACE_cond_t *cv, short type, const wchar_t *name, void *arg = 0) `[static]`
- cond_init(ACE_cond_t *cv, ACE_condattr_t &attributes, const wchar_t *name, void *arg = 0) `[static]`
- cond_signal(ACE_cond_t *cv) `[static]`
- cond_timedwait(ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *) `[static]`
- cond_timedwait_i(ACE_cond_t *cv, ACE_mutex_t *m, ACE_Time_Value *) `[private, static]`
- cond_wait(ACE_cond_t *cv, ACE_mutex_t *m) `[static]`
- condattr_destroy(ACE_condattr_t &attributes) `[static]`
- condattr_init(ACE_condattr_t &attributes, int type = ACE_DEFAULT_SYNCH_TYPE) `[static]`
- connect(ACE_HANDLE handle, struct sockaddr *addr, int addrlen) `[static]`
- connect(ACE_HANDLE handle, const sockaddr *addr, int addrlen, const ACE_QoS_Params &qos_params) `[static]`
- creat(const ACE_TCHAR *filename, mode_t mode) `[static]`
- ctime(const time_t *t) `[static]`
- ctime_r(const time_t *clock, ACE_TCHAR *buf, int buflen) `[static]`
- cuserid(char *user, size_t maxlen = ACE_MAX_USERID) `[static]`
- cuserid(wchar_t *user, size_t maxlen = ACE_MAX_USERID) `[static]`
- default_win32_security_attributes(LPSECURITY_ATTRIBUTES) `[static]`
- difftime(time_t t1, time_t t0) `[static]`
- dlclose(ACE_SHLIB_HANDLE handle) `[static]`
- dlerror(void) `[static]`
- dlopen(const ACE_TCHAR *filename, int mode = ACE_DEFAULT_SHLIB_MODE) `[static]`
- dlsym(ACE_SHLIB_HANDLE handle, const ACE_TCHAR *symbol) `[static]`
- dup(ACE_HANDLE handle) `[static]`
- dup2(ACE_HANDLE oldfd, ACE_HANDLE newfd) `[static]`
- endpwent(void) `[static]`
- enum_protocols(int *protocols, ACE_Protocol_Info *protocol_buffer, u_long *buffer_length) `[static]`
- event_destroy(ACE_event_t *event) `[static]`
- event_init(ACE_event_t *event, int manual_reset = 0, int initial_state = 0, int type = ACE_DEFAULT_SYNCH_TYPE, const char *name = 0, void *arg = 0, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- event_init(ACE_event_t *event, int manual_reset, int initial_state, int type, const wchar_t *name, void *arg = 0, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- event_pulse(ACE_event_t *event) `[static]`
- event_reset(ACE_event_t *event) `[static]`
- event_signal(ACE_event_t *event) `[static]`
- event_timedwait(ACE_event_t *event, ACE_Time_Value *timeout) `[static]`
- event_wait(ACE_event_t *event) `[static]`
- execl(const char *path, const char *arg0, ...) `[static]`
- execle(const char *path, const char *arg0, ...) `[static]`
- execlp(const char *file, const char *arg0, ...) `[static]`
- execv(const char *path, char *const argv[]) `[static]`
- execve(const char *path, char *const argv[], char *const envp[]) `[static]`
- execvp(const char *file, char *const argv[]) `[static]`
- exit(int status = 0) `[static]`
- exit_hook_ `[private, static]`
- fattach(int handle, const char *path) `[static]`
- fclose(FILE *fp) `[static]`
- fcntl(ACE_HANDLE handle, int cmd, long arg = 0) `[static]`
- fdetach(const char *file) `[static]`
- fdopen(ACE_HANDLE handle, const ACE_TCHAR *mode) `[static]`
- fflush(FILE *fp) `[static]`
- fgets(ACE_TCHAR *buf, int size, FILE *fp) `[static]`
- filesize(ACE_HANDLE handle) `[static]`
- filesize(const ACE_TCHAR *handle) `[static]`
- flock_destroy(ACE_OS::ace_flock_t *lock, int unlink_file = 1) `[static]`
- flock_init(ACE_OS::ace_flock_t *lock, int flags = 0, const ACE_TCHAR *name = 0, mode_t perms = 0) `[static]`
- flock_rdlock(ACE_OS::ace_flock_t *lock, short whence = 0, off_t start = 0, off_t len = 0) `[static]`
- flock_tryrdlock(ACE_OS::ace_flock_t *lock, short whence = 0, off_t start = 0, off_t len = 0) `[static]`
- flock_trywrlock(ACE_OS::ace_flock_t *lock, short whence = 0, off_t start = 0, off_t len = 0) `[static]`
- flock_unlock(ACE_OS::ace_flock_t *lock, short whence = 0, off_t start = 0, off_t len = 0) `[static]`
- flock_wrlock(ACE_OS::ace_flock_t *lock, short whence = 0, off_t start = 0, off_t len = 0) `[static]`
- floor(double x) `[static]`
- fopen(const ACE_TCHAR *filename, const ACE_TCHAR *mode) `[static]`
- fopen_mode_to_open_mode_converter(ACE_TCHAR x, int &hmode) `[private, static]`
- fork(void) `[static]`
- fork(const ACE_TCHAR *program_name) `[static]`
- fork_exec(ACE_TCHAR *argv[]) `[static]`
- fprintf(FILE *fp, const char *format, ...) `[static]`
- fprintf(FILE *fp, const wchar_t *format, ...) `[static]`
- fputs(const ACE_TCHAR *s, FILE *stream) `[static]`
- fread(void *ptr, size_t size, size_t nelems, FILE *fp) `[static]`
- free(void *) `[static]`
- fseek(FILE *fp, long offset, int ptrname) `[static]`
- fstat(ACE_HANDLE, ACE_stat *) `[static]`
- fsync(ACE_HANDLE handle) `[static]`
- ftruncate(ACE_HANDLE, off_t) `[static]`
- fwrite(const void *ptr, size_t size, size_t nitems, FILE *fp) `[static]`
- get_win32_resource_module(void) `[static]`
- get_win32_versioninfo(void) `[static]`
- getcwd(ACE_TCHAR *, size_t) `[static]`
- getenv(const char *symbol) `[static]`
- getenv(const wchar_t *symbol) `[static]`
- getenvstrings(void) `[static]`
- getgid(void) `[static]`
- gethostbyaddr(const char *addr, int length, int type) `[static]`
- gethostbyaddr_r(const char *addr, int length, int type, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop) `[static]`
- gethostbyname(const char *name) `[static]`
- gethostbyname2(const char *name, int type) `[static]`
- gethostbyname_r(const char *name, struct hostent *result, ACE_HOSTENT_DATA buffer, int *h_errnop) `[static]`
- gethrtime(const ACE_HRTimer_Op = ACE_HRTIMER_GETTIME) `[static]`
- getmsg(ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *flags) `[static]`
- getopt(int argc, char *const *argv, const char *optstring) `[static]`
- getpagesize(void) `[static]`
- getpeername(ACE_HANDLE handle, struct sockaddr *addr, int *addrlen) `[static]`
- getpgid(pid_t pid) `[static]`
- getpid(void) `[static]`
- getpmsg(ACE_HANDLE handle, struct strbuf *ctl, struct strbuf *data, int *band, int *flags) `[static]`
- getppid(void) `[static]`
- getprotobyname(const char *name) `[static]`
- getprotobyname_r(const char *name, struct protoent *result, ACE_PROTOENT_DATA buffer) `[static]`
- getprotobynumber(int proto) `[static]`
- getprotobynumber_r(int proto, struct protoent *result, ACE_PROTOENT_DATA buffer) `[static]`
- getpwent(void) `[static]`
- getpwnam(const char *user) `[static]`
- getpwnam_r(const char *name, struct passwd *pwent, char *buffer, int buflen) `[static]`
- getrlimit(int resource, struct rlimit *rl) `[static]`
- getrusage(int who, struct rusage *rusage) `[static]`
- gets(char *str, int n = 0) `[static]`
- getservbyname(const char *svc, const char *proto) `[static]`
- getservbyname_r(const char *svc, const char *proto, struct servent *result, ACE_SERVENT_DATA buf) `[static]`
- getsockname(ACE_HANDLE handle, struct sockaddr *addr, int *addrlen) `[static]`
- getsockopt(ACE_HANDLE handle, int level, int optname, char *optval, int *optlen) `[static]`
- gettimeofday(void) `[static]`
- gettimeofday_i(void) `[private, static]`
- getuid(void) `[static]`
- gmtime(const time_t *clock) `[static]`
- gmtime_r(const time_t *clock, struct tm *res) `[static]`
- hostname(char *name, size_t maxnamelen) `[static]`
- hostname(wchar_t *name, size_t maxnamelen) `[static]`
- inet_addr(const char *name) `[static]`
- inet_aton(const char *strptr, struct in_addr *addr) `[static]`
- inet_ntoa(const struct in_addr addr) `[static]`
- inet_ntop(int family, const void *addrptr, char *strptr, size_t len) `[static]`
- inet_pton(int family, const char *strptr, void *addrptr) `[static]`
- ioctl(ACE_HANDLE handle, int cmd, void * = 0) `[static]`
- ioctl(ACE_HANDLE socket, u_long io_control_code, void *in_buffer_p, u_long in_buffer, void *out_buffer_p, u_long out_buffer, u_long *bytes_returned, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func) `[static]`
- ioctl(ACE_HANDLE socket, u_long io_control_code, ACE_QoS &ace_qos, u_long *bytes_returned, void *buffer_p = 0, u_long buffer = 0, ACE_OVERLAPPED *overlapped = 0, ACE_OVERLAPPED_COMPLETION_FUNC func = 0) `[static]`
- isastream(ACE_HANDLE handle) `[static]`
- isatty(int handle) `[static]`
- isatty(ACE_HANDLE handle) `[static]`
- itoa(int value, char *string, int radix) `[static]`
- itoa(int value, wchar_t *string, int radix) `[static]`
- join_leaf(ACE_HANDLE socket, const sockaddr *name, int namelen, const ACE_QoS_Params &qos_params) `[static]`
- kill(pid_t pid, int signum) `[static]`
- last_error(void) `[static]`
- last_error(int) `[static]`
- listen(ACE_HANDLE handle, int backlog) `[static]`
- localtime(const time_t *clock) `[static]`
- localtime_r(const time_t *clock, struct tm *res) `[static]`
- lseek(ACE_HANDLE handle, off_t offset, int whence) `[static]`
- lstat(const char *, ACE_stat *) `[static]`
- lwp_getparams(ACE_Sched_Params &) `[static]`
- lwp_setparams(const ACE_Sched_Params &) `[static]`
- madvise(caddr_t addr, size_t len, int advice) `[static]`
- malloc(size_t) `[static]`
- memchr(const void *s, int c, size_t len) `[static]`
- memchr(void *s, int c, size_t len) `[static]`
- memcmp(const void *t, const void *s, size_t len) `[static]`
- memcpy(void *t, const void *s, size_t len) `[static]`
- memmove(void *t, const void *s, size_t len) `[static]`
- memset(void *s, int c, size_t len) `[static]`
- mkdir(const ACE_TCHAR *path, mode_t mode = ACE_DEFAULT_DIR_PERMS) `[static]`
- mkfifo(const ACE_TCHAR *file, mode_t mode = ACE_DEFAULT_FILE_PERMS) `[static]`
- mkstemp(ACE_TCHAR *t) `[static]`
- mktemp(ACE_TCHAR *t) `[static]`
- mktime(struct tm *timeptr) `[static]`
- mmap(void *addr, size_t len, int prot, int flags, ACE_HANDLE handle, off_t off = 0, ACE_HANDLE *file_mapping = 0, LPSECURITY_ATTRIBUTES sa = 0, const ACE_TCHAR *file_mapping_name = 0) `[static]`
- mprotect(void *addr, size_t len, int prot) `[static]`
- msgctl(int msqid, int cmd, struct msqid_ds *) `[static]`
- msgget(key_t key, int msgflg) `[static]`
- msgrcv(int int_id, void *buf, size_t len, long type, int flags) `[static]`
- msgsnd(int int_id, const void *buf, size_t len, int flags) `[static]`
- msync(void *addr, size_t len, int sync) `[static]`
- munmap(void *addr, size_t len) `[static]`
- mutex_destroy(ACE_mutex_t *m) `[static]`
- mutex_init(ACE_mutex_t *m, int type = ACE_DEFAULT_SYNCH_TYPE, const char *name = 0, ACE_mutexattr_t *arg = 0, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- mutex_init(ACE_mutex_t *m, int type, const wchar_t *name, ACE_mutexattr_t *arg = 0, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- mutex_lock(ACE_mutex_t *m) `[static]`
- mutex_lock(ACE_mutex_t *m, int &abandoned) `[static]`
- mutex_lock(ACE_mutex_t *m, const ACE_Time_Value &timeout) `[static]`
- mutex_lock(ACE_mutex_t *m, const ACE_Time_Value *timeout) `[static]`
- mutex_lock_cleanup(void *mutex) `[static]`
- mutex_trylock(ACE_mutex_t *m) `[static]`
- mutex_trylock(ACE_mutex_t *m, int &abandoned) `[static]`
- mutex_unlock(ACE_mutex_t *m) `[static]`
- nanosleep(const struct timespec *requested, struct timespec *remaining = 0) `[static]`
- nanosleep_i(const struct timespec *requested, struct timespec *remaining = 0) `[private, static]`
- NULL_hthread `[static]`
- NULL_key `[static]`
- NULL_thread `[static]`
- open(const char *filename, int mode, int perms = ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- open(const wchar_t *filename, int mode, int perms = ACE_DEFAULT_OPEN_PERMS, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- opendir(const ACE_TCHAR *filename) `[static]`
- perror(const ACE_TCHAR *s) `[static]`
- pipe(ACE_HANDLE handles[]) `[static]`
- poll(struct pollfd *pollfds, u_long len, const ACE_Time_Value *tv = 0) `[static]`
- poll(struct pollfd *pollfds, u_long len, const ACE_Time_Value &tv) `[static]`
- poll_i(struct pollfd *pollfds, u_long len, const ACE_Time_Value *tv = 0) `[private, static]`
- poll_i(struct pollfd *pollfds, u_long len, const ACE_Time_Value &tv) `[private, static]`
- pread(ACE_HANDLE handle, void *buf, size_t nbyte, off_t offset) `[static]`
- printf(const char *format, ...) `[static]`
- priority_control(ACE_idtype_t, ACE_id_t, int, void *) `[static]`
- pthread_sigmask(int how, const sigset_t *nsp, sigset_t *osp) `[static]`
- putenv(const ACE_TCHAR *string) `[static]`
- putmsg(ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int flags) `[static]`
- putpmsg(ACE_HANDLE handle, const struct strbuf *ctl, const struct strbuf *data, int band, int flags) `[static]`
- puts(const ACE_TCHAR *s) `[static]`
- pwrite(ACE_HANDLE handle, const void *buf, size_t nbyte, off_t offset) `[static]`
- qsort(void *base, size_t nel, size_t width, ACE_COMPARE_FUNC) `[static]`
- rand(void) `[static]`
- rand_r(ACE_RANDR_TYPE &seed) `[static]`
- read(ACE_HANDLE handle, void *buf, size_t len) `[static]`
- read(ACE_HANDLE handle, void *buf, size_t len, ACE_OVERLAPPED *) `[static]`
- read_n(ACE_HANDLE handle, void *buf, size_t len, size_t *bytes_transferred = 0) `[static]`
- readdir(ACE_DIR *) `[static]`
- readdir_r(ACE_DIR *dirp, dirent *entry, dirent **result) `[static]`
- readlink(const char *path, char *buf, size_t bufsiz) `[static]`
- readv(ACE_HANDLE handle, iovec *iov, int iovlen) `[static]`
- realloc(void *, size_t) `[static]`
- recursive_mutex_destroy(ACE_recursive_thread_mutex_t *m) `[static]`
- recursive_mutex_init(ACE_recursive_thread_mutex_t *m, const ACE_TCHAR *name = 0, ACE_mutexattr_t *arg = 0, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- recursive_mutex_lock(ACE_recursive_thread_mutex_t *m) `[static]`
- recursive_mutex_trylock(ACE_recursive_thread_mutex_t *m) `[static]`
- recursive_mutex_unlock(ACE_recursive_thread_mutex_t *m) `[static]`
- recv(ACE_HANDLE handle, char *buf, int len, int flags = 0) `[static]`
- recvfrom(ACE_HANDLE handle, char *buf, int len, int flags, struct sockaddr *addr, int *addrlen) `[static]`
- recvfrom(ACE_HANDLE handle, iovec *buffers, int buffer_count, size_t &number_of_bytes_recvd, int &flags, struct sockaddr *addr, int *addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func) `[static]`
- recvmsg(ACE_HANDLE handle, struct msghdr *msg, int flags) `[static]`
- recvv(ACE_HANDLE handle, iovec *iov, int iovlen) `[static]`
- rename(const ACE_TCHAR *old_name, const ACE_TCHAR *new_name, int flags = -1) `[static]`
- rewind(FILE *fp) `[static]`
- rewinddir(ACE_DIR *) `[static]`
- rw_rdlock(ACE_rwlock_t *rw) `[static]`
- rw_tryrdlock(ACE_rwlock_t *rw) `[static]`
- rw_trywrlock(ACE_rwlock_t *rw) `[static]`
- rw_trywrlock_upgrade(ACE_rwlock_t *rw) `[static]`
- rw_unlock(ACE_rwlock_t *rw) `[static]`
- rw_wrlock(ACE_rwlock_t *rw) `[static]`
- rwlock_destroy(ACE_rwlock_t *rw) `[static]`
- rwlock_init(ACE_rwlock_t *rw, int type = ACE_DEFAULT_SYNCH_TYPE, const ACE_TCHAR *name = 0, void *arg = 0) `[static]`
- sbrk(int brk) `[static]`
- scandir(const ACE_TCHAR *dirname, dirent **namelist[], int (*selector) (const dirent *filename), int (*comparator) (const dirent **f1, const dirent **f2)) `[static]`
- sched_params(const ACE_Sched_Params &, ACE_id_t id = ACE_SELF) `[static]`
- scheduling_class(const char *class_name, ACE_id_t &) `[static]`
- seekdir(ACE_DIR *, long loc) `[static]`
- select(int width, fd_set *rfds, fd_set *wfds = 0, fd_set *efds = 0, const ACE_Time_Value *tv = 0) `[static]`
- select(int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv) `[static]`
- select_i(int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value *tv = 0) `[private, static]`
- select_i(int width, fd_set *rfds, fd_set *wfds, fd_set *efds, const ACE_Time_Value &tv) `[private, static]`
- sema_destroy(ACE_sema_t *s) `[static]`
- sema_init(ACE_sema_t *s, u_int count, int type = ACE_DEFAULT_SYNCH_TYPE, const char *name = 0, void *arg = 0, int max = 0x7fffffff, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- sema_init(ACE_sema_t *s, u_int count, int type, const wchar_t *name, void *arg = 0, int max = 0x7fffffff, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- sema_post(ACE_sema_t *s) `[static]`
- sema_post(ACE_sema_t *s, size_t release_count) `[static]`
- sema_trywait(ACE_sema_t *s) `[static]`
- sema_wait(ACE_sema_t *s) `[static]`
- sema_wait(ACE_sema_t *s, ACE_Time_Value &tv) `[static]`
- sema_wait(ACE_sema_t *s, ACE_Time_Value *tv) `[static]`
- sema_wait_i(ACE_sema_t *s) `[private, static]`
- sema_wait_i(ACE_sema_t *s, ACE_Time_Value &tv) `[private, static]`
- semctl(int int_id, int semnum, int cmd, semun) `[static]`
- semget(key_t key, int nsems, int flags) `[static]`
- semop(int int_id, struct sembuf *sops, size_t nsops) `[static]`
- send(ACE_HANDLE handle, const char *buf, int len, int flags = 0) `[static]`
- sendmsg(ACE_HANDLE handle, const struct msghdr *msg, int flags) `[static]`
- sendto(ACE_HANDLE handle, const char *buf, int len, int flags, const struct sockaddr *addr, int addrlen) `[static]`
- sendto(ACE_HANDLE handle, const iovec *buffers, int buffer_count, size_t &number_of_bytes_sent, int flags, const struct sockaddr *addr, int addrlen, ACE_OVERLAPPED *overlapped, ACE_OVERLAPPED_COMPLETION_FUNC func) `[static]`
- sendv(ACE_HANDLE handle, const iovec *iov, int iovcnt) `[static]`
- set_errno_to_last_error(void) `[static]`
- set_errno_to_wsa_last_error(void) `[static]`
- set_exit_hook(ACE_EXIT_HOOK hook) `[private, static]`
- set_scheduling_params(const ACE_Sched_Params &, ACE_id_t id = ACE_SELF) `[static]`
- set_win32_resource_module(HINSTANCE) `[static]`
- setgid(gid_t) `[static]`
- setpgid(pid_t pid, pid_t pgid) `[static]`
- setpwent(void) `[static]`
- setregid(gid_t rgid, gid_t egid) `[static]`
- setreuid(uid_t ruid, uid_t euid) `[static]`
- setrlimit(int resource, ACE_SETRLIMIT_TYPE *rl) `[static]`
- setsid(void) `[static]`
- setsockopt(ACE_HANDLE handle, int level, int optname, const char *optval, int optlen) `[static]`
- setuid(uid_t) `[static]`
- shm_open(const ACE_TCHAR *filename, int mode, int perms = 0, LPSECURITY_ATTRIBUTES sa = 0) `[static]`
- shm_unlink(const ACE_TCHAR *path) `[static]`
- shmat(int int_id, void *shmaddr, int shmflg) `[static]`
- shmctl(int int_id, int cmd, struct shmid_ds *buf) `[static]`
- shmdt(void *shmaddr) `[static]`
- shmget(key_t key, int size, int flags) `[static]`
- shutdown(ACE_HANDLE handle, int how) `[static]`
- sigaction(int signum, const struct sigaction *nsa, struct sigaction *osa) `[static]`
- sigaddset(sigset_t *s, int signum) `[static]`
- sigdelset(sigset_t *s, int signum) `[static]`
- sigemptyset(sigset_t *s) `[static]`
- sigfillset(sigset_t *s) `[static]`
- sigismember(sigset_t *s, int signum) `[static]`
- signal(int signum, ACE_SignalHandler) `[static]`
- sigprocmask(int how, const sigset_t *nsp, sigset_t *osp) `[static]`
- sigsuspend(const sigset_t *set) `[static]`
- sigtimedwait(const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout) `[static]`
- sigtimedwait_i(const sigset_t *set, siginfo_t *info, const ACE_Time_Value *timeout) `[private, static]`
- sigwait(sigset_t *set, int *sig = 0) `[static]`
- sleep(u_int seconds) `[static]`
- sleep(const ACE_Time_Value &tv) `[static]`
- sleep_i(u_int seconds) `[private, static]`
- sleep_i(const ACE_Time_Value &tv) `[private, static]`
- socket(int protocol_family, int type, int proto) `[static]`
- socket(int protocol_family, int type, int proto, ACE_Protocol_Info *protocolinfo, ACE_SOCK_GROUP g, u_long flags) `[static]`
- socket_fini(void) `[static]`
- socket_init(int version_high = 1, int version_low = 1) `[static]`
- socket_initialized_ `[static]`
- socketpair(int domain, int type, int protocol, ACE_HANDLE sv[2]) `[static]`
- sprintf(char *buf, const char *format, ...) `[static]`
- sprintf(wchar_t *buf, const wchar_t *format, ...) `[static]`
- srand(u_int seed) `[static]`
- stat(const ACE_TCHAR *file, ACE_stat *) `[static]`
- step(const char *str, char *expbuf) `[static]`
- strcasecmp(const char *s, const char *t) `[static]`
- strcasecmp(const wchar_t *s, const wchar_t *t) `[static]`
- strcat(char *s, const char *t) `[static]`
- strcat(wchar_t *s, const wchar_t *t) `[static]`
- strchr(const char *s, int c) `[static]`
- strchr(const wchar_t *s, wint_t c) `[static]`
- strchr(char *s, int c) `[static]`
- strchr(wchar_t *s, wint_t c) `[static]`
- strcmp(const char *s, const char *t) `[static]`
- strcmp(const wchar_t *s, const wchar_t *t) `[static]`
- strcpy(char *s, const char *t) `[static]`
- strcpy(wchar_t *s, const wchar_t *t) `[static]`
- strcspn(const char *s, const char *reject) `[static]`
- strcspn(const wchar_t *s, const wchar_t *reject) `[static]`
- strdup(const char *s) `[static]`
- strdup(const wchar_t *s) `[static]`
- strecpy(char *des, const char *src) `[static]`
- strecpy(wchar_t *s, const wchar_t *t) `[static]`
- strenvdup(const ACE_TCHAR *str) `[static]`
- strerror(int errnum) `[static]`
- strftime(char *s, size_t maxsize, const char *format, const struct tm *timeptr) `[static]`
- string_to_argv(ACE_TCHAR *buf, size_t &argc, ACE_TCHAR **&argv, int substitute_env_args = 1) `[static]`
- strlen(const char *s) `[static]`
- strlen(const wchar_t *s) `[static]`
- strncasecmp(const char *s, const char *t, size_t len) `[static]`
- strncasecmp(const wchar_t *s, const wchar_t *t, size_t len) `[static]`
- strncat(char *s, const char *t, size_t len) `[static]`
- strncat(wchar_t *s, const wchar_t *t, size_t len) `[static]`
- strnchr(const char *s, int c, size_t len) `[static]`
- strnchr(const wchar_t *s, wint_t c, size_t len) `[static]`
- strnchr(char *s, int c, size_t len) `[static]`
- strnchr(wchar_t *s, wint_t c, size_t len) `[static]`
- strncmp(const char *s, const char *t, size_t len) `[static]`
- strncmp(const wchar_t *s, const wchar_t *t, size_t len) `[static]`
- strncpy(char *s, const char *t, size_t len) `[static]`
- strncpy(wchar_t *s, const wchar_t *t, size_t len) `[static]`
- strnstr(const char *s, const char *t, size_t len) `[inline, static]`
- strnstr(const wchar_t *s, const wchar_t *t, size_t len) `[static]`
- strnstr(char *s, const char *t, size_t len) `[static]`
- strnstr(wchar_t *s, const wchar_t *t, size_t len) `[static]`
- strpbrk(const char *s1, const char *s2) `[static]`
- strpbrk(const wchar_t *s1, const wchar_t *s2) `[static]`
- strpbrk(char *s1, const char *s2) `[static]`
- strpbrk(wchar_t *s1, const wchar_t *s2) `[static]`
- strrchr(const char *s, int c) `[static]`
- strrchr(const wchar_t *s, wint_t c) `[static]`
- strrchr(char *s, int c) `[static]`
- strrchr(wchar_t *s, wint_t c) `[static]`
- strsncpy(char *dst, const char *src, size_t maxlen) `[static]`
- strsncpy(wchar_t *dst, const wchar_t *src, size_t maxlen) `[static]`
- strspn(const char *s1, const char *s2) `[static]`
- strspn(const wchar_t *s1, const wchar_t *s2) `[static]`
- strstr(const char *s, const char *t) `[static]`
- strstr(const wchar_t *s, const wchar_t *t) `[static]`
- strstr(char *s, const char *t) `[static]`
- strstr(wchar_t *s, const wchar_t *t) `[static]`
- strtod(const char *s, char **endptr) `[static]`
- strtod(const wchar_t *s, wchar_t **endptr) `[static]`
- strtok(char *s, const char *tokens) `[static]`
- strtok(wchar_t *s, const wchar_t *tokens) `[static]`
- strtok_r(char *s, const char *tokens, char **lasts) `[static]`
- strtol(const char *s, char **ptr, int base) `[static]`
- strtol(const wchar_t *s, wchar_t **ptr, int base) `[static]`
- strtoul(const char *s, char **ptr, int base) `[static]`
- strtoul(const wchar_t *s, wchar_t **ptr, int base) `[static]`
- sysconf(int) `[static]`
- sysinfo(int cmd, char *buf, long count) `[static]`
- system(const ACE_TCHAR *s) `[static]`
- t_accept(ACE_HANDLE fildes, ACE_HANDLE resfd, struct t_call *call) `[static]`
- t_alloc(ACE_HANDLE fildes, int struct_type, int fields) `[static]`
- t_bind(ACE_HANDLE fildes, struct t_bind *req, struct t_bind *ret) `[static]`
- t_close(ACE_HANDLE fildes) `[static]`
- t_connect(ACE_HANDLE fildes, struct t_call *sndcall, struct t_call *rcvcall) `[static]`
- t_error(const char *errmsg) `[static]`
- t_free(char *ptr, int struct_type) `[static]`
- t_getinfo(ACE_HANDLE fildes, struct t_info *info) `[static]`
- t_getname(ACE_HANDLE fildes, struct netbuf *namep, int type) `[static]`
- t_getstate(ACE_HANDLE fildes) `[static]`
- t_listen(ACE_HANDLE fildes, struct t_call *call) `[static]`
- t_look(ACE_HANDLE fildes) `[static]`
- t_open(char *path, int oflag, struct t_info *info) `[static]`
- t_optmgmt(ACE_HANDLE fildes, struct t_optmgmt *req, struct t_optmgmt *ret) `[static]`
- t_rcv(ACE_HANDLE fildes, char *buf, unsigned int nbytes, int *flags) `[static]`
- t_rcvdis(ACE_HANDLE fildes, struct t_discon *discon) `[static]`
- t_rcvrel(ACE_HANDLE fildes) `[static]`
- t_rcvudata(ACE_HANDLE fildes, struct t_unitdata *unitdata, int *flags) `[static]`
- t_rcvuderr(ACE_HANDLE fildes, struct t_uderr *uderr) `[static]`
- t_snd(ACE_HANDLE fildes, const char *buf, unsigned int nbytes, int flags) `[static]`
- t_snddis(ACE_HANDLE fildes, struct t_call *call) `[static]`
- t_sndrel(ACE_HANDLE fildes) `[static]`
- t_sync(ACE_HANDLE fildes) `[static]`
- t_unbind(ACE_HANDLE fildes) `[static]`
- telldir(ACE_DIR *) `[static]`
- tempnam(const ACE_TCHAR *dir = 0, const ACE_TCHAR *pfx = 0) `[static]`
- thr_cancel(ACE_thread_t t_id) `[static]`
- thr_cmp(ACE_hthread_t t1, ACE_hthread_t t2) `[static]`
- thr_continue(ACE_hthread_t target_thread) `[static]`
- thr_create(ACE_THR_FUNC func, void *args, long flags, ACE_thread_t *thr_id, ACE_hthread_t *t_handle = 0, long priority = ACE_DEFAULT_THREAD_PRIORITY, void *stack = 0, size_t stacksize = 0, ACE_Base_Thread_Adapter *thread_adapter = 0) `[static]`
- thr_equal(ACE_thread_t t1, ACE_thread_t t2) `[static]`
- thr_exit(void *status = 0) `[static]`
- thr_getconcurrency(void) `[static]`
- thr_getprio(ACE_hthread_t thr_id, int &prio) `[static]`
- thr_getspecific(ACE_thread_key_t key, void **data) `[static]`
- thr_join(ACE_hthread_t waiter_id, void **status) `[static]`
- thr_join(ACE_thread_t waiter_id, ACE_thread_t *thr_id, void **status) `[static]`
- thr_key_detach(void *inst) `[static]`
- thr_key_used(ACE_thread_key_t key) `[static]`
- thr_keycreate(ACE_thread_key_t *key, ACE_THR_DEST, void *inst = 0) `[static]`
- thr_keyfree(ACE_thread_key_t key) `[static]`
- thr_kill(ACE_thread_t thr_id, int signum) `[static]`
- thr_min_stack(void) `[static]`
- thr_self(void) `[static]`
- thr_self(ACE_hthread_t &) `[static]`
- thr_setcancelstate(int new_state, int *old_state) `[static]`
- thr_setcanceltype(int new_type, int *old_type) `[static]`
- thr_setconcurrency(int hint) `[static]`
- thr_setprio(ACE_hthread_t thr_id, int prio) `[static]`
- thr_setprio(const ACE_Sched_Priority prio) `[static]`
- thr_setspecific(ACE_thread_key_t key, void *data) `[static]`
- thr_sigsetmask(int how, const sigset_t *nsm, sigset_t *osm) `[static]`
- thr_suspend(ACE_hthread_t target_thread) `[static]`
- thr_testcancel(void) `[static]`
- thr_yield(void) `[static]`
- thread_mutex_destroy(ACE_thread_mutex_t *m) `[static]`
- thread_mutex_init(ACE_thread_mutex_t *m, int type = ACE_DEFAULT_SYNCH_TYPE, const char *name = 0, ACE_mutexattr_t *arg = 0) `[static]`
- thread_mutex_init(ACE_thread_mutex_t *m, int type, const wchar_t *name, ACE_mutexattr_t *arg = 0) `[static]`
- thread_mutex_lock(ACE_thread_mutex_t *m) `[static]`
- thread_mutex_lock(ACE_thread_mutex_t *m, const ACE_Time_Value &timeout) `[static]`
- thread_mutex_lock(ACE_thread_mutex_t *m, const ACE_Time_Value *timeout) `[static]`
- thread_mutex_trylock(ACE_thread_mutex_t *m) `[static]`
- thread_mutex_unlock(ACE_thread_mutex_t *m) `[static]`
- time(time_t *tloc = 0) `[static]`
- timezone(void) `[static]`
- to_lower(int c) `[static]`
- to_lower(wint_t c) `[static]`
- truncate(const ACE_TCHAR *filename, off_t length) `[static]`
- tzset(void) `[static]`
- ualarm(u_int usecs, u_int interval = 0) `[static]`
- ualarm(const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval = ACE_Time_Value::zero) `[static]`
- ualarm_i(u_int usecs, u_int interval = 0) `[private, static]`
- ualarm_i(const ACE_Time_Value &tv, const ACE_Time_Value &tv_interval = ACE_Time_Value::zero) `[private, static]`
- umask(mode_t cmask) `[static]`
- uname(ACE_utsname *name) `[static]`
- unique_name(const void *object, ACE_TCHAR *name, size_t length) `[static]`
- unlink(const ACE_TCHAR *path) `[static]`
- vsprintf(char *buffer, const char *format, va_list argptr) `[static]`
- vsprintf(wchar_t *buffer, const wchar_t *format, va_list argptr) `[static]`
- wait(pid_t pid, ACE_exitcode *status, int wait_options = 0, ACE_HANDLE handle = 0) `[static]`
- wait(int * = 0) `[static]`
- waitpid(pid_t pid, ACE_exitcode *status = 0, int wait_options = 0, ACE_HANDLE handle = 0) `[static]`
- WChar typedef
- win32_resource_module_ `[private, static]`
- win32_versioninfo_ `[private, static]`
- write(ACE_HANDLE handle, const void *buf, size_t nbyte) `[static]`
- write(ACE_HANDLE handle, const void *buf, size_t nbyte, ACE_OVERLAPPED *) `[static]`
- write_n(ACE_HANDLE handle, const void *buf, size_t len, size_t *bytes_transferred = 0) `[static]`
- writev(ACE_HANDLE handle, const iovec *iov, int iovcnt) `[static]`
- wscmp(const WChar *, const WChar *) `[static]`
- wscpy(WChar *, const WChar *) `[static]`
- wslen(const WChar *) `[static]`
- wsncmp(const WChar *, const WChar *, size_t len) `[static]`