Contents

Preface

Guide to OS Services

CommonPoint information set

Getting started

Taxonomy

Developer guides

Usage and tools guidelines

Application documentation

Documented sample programs and sample code

Installation and late-breaking information

Typographical conventions

Reading notation diagrams

Kernel Services

Threads and tasks

Scheduling

Creating a thread

Cancelling a thread

Changing a thread's schedule

Creating a task

Destroying a task

Synchronizing threads

Semaphores

Local and recoverable semaphores

Creating a semaphore

Acquiring a semaphore

Releasing a semaphore

Counting semaphores

Creating a counting semaphore

Decrementing a counting semaphore

Incrementing a counting semaphore

Monitors

Monitor conditions

Creating a monitor class

Entering a monitor

Leaving a monitor

Using a monitor condition

Runtime Services

Exceptions

Deriving from TStandardException

Throwing an exception

Displaying error messages

Designing a custom error message format

Heaps

Local and shared heaps

Creating a local heap

Creating a shared heap

Allocating on a non-default heap

Deleting an object from a heap

Reallocating a previously freed raw memory block

Iterating among the available heaps

System shutdown

Writing a shutdown handler

Communications access

Understanding communications access

Locating services

Defining services

Service Access classes

Characteristics of services

Publishing and activating services

Establishing a communications channel

The message streams communication model

Implementing request-reply communication

Communications access classes

Service Access classes

Service definitions and service references

Base classes

Standard services

Named services

Network services

Service names and visibility

Exception classes

Message Streams classes

Creating a service definition

Creating a service reference

Creating a reference on the server side

Creating a reference on the client side

Defining a request-reply server

Initializing the server

Handling requests

Terminating the server

Defining a request-reply client

Initializing the client

Issuing requests

Terminating the client

File System interface

Understanding the File System interface

Working with physical entities

Accessing file contents

Copying and moving files

Iterating through volumes and directories

Accessing properties

Using pathnames

Flattening and resurrecting file system entities

Multithread safety with file system entities

Memory management

File system classes

File system entities

Pathname and parser

Accessing data

Iterating through directories and volumes

Moving and copying file system instances

Using file system entities and pathnames

Using TPathName

Obtaining a file system entity from a pathname

Obtaining a pathname from a file system entity

Directories and TDirectory

Looking up entities within a directory

Creating a new directory

Creating a new file

Deleting directories and their contents

Volumes and TVolume

Files and TFile

Getting a file or directory instance

Deleting a file

Accessing data

Creating a named persistent stream

Creating a mapped file

Mapping a file into memory

Using a file range with a mapped file

File system properties

Accessing file system properties

Behavior of file system properties

Accessing file system properties using functions

Accessing file system properties using identifiers

Moving and copying file system instances

Copying entities between directories

Moving entities between directories

Moving entities from one volume to another

Iterating through directories and volumes

Iterating a directory

Using TDirectoryIterator

Using TDirectoryTreeIterator

Iterating through all mounted volumes

Exception handling

Time services

Getting started with the Time services

Getting the current time

Setting a delay on the system clock

Timing concepts

Time

Clocks

TSystemClock

TDateTimeClock

TSyncableClock

TStopwatch

Syncable clocks

Rate

Clock times

Comparing times

Representing timing dependencies

Deleting syncable clocks

Setting a delay

Delaying until a specific time

Delaying for a specific time interval

Programming around time flowing backward

Performing tasks periodically

Adding a time unit

Implementing a clock and time source

Implementing a clock

Implementing a time source

Using a driven- time source

Deriving a time source from TTimeSource