left-pointing blue arrow click to put Class Index into the index pane


abstract_command_object

library: classics header: command_object.h usage: main API

This is a common interface used for command objects. It has a virtual operator() function, which is to be invoked by the consumer of the command.

See abstract_command_object documentation.

See also class APC_server.

address_t

library: classics header: common.h usage: main API

A typedef for an integer that is the same size as a pointer. It is designed for clairity when manipulating pointers as ints, and for portability between 32-bit and 64-bit platforms. It is defined as unsigned int under Win32. It is also defined as __int64 for 64-bit windows, but this is provisional since that is not supported yet.


APC_server

library: classics header: APC_server.h usage: main API

This class creates and manages a thread that can then be fed work via a queue of command objects.

See APC_server documentation.

See also class abstract_command_object.


atomic_counter

library: classics header: atomic_counter.h usage: template, main API

This provides a counter that can be incremented (or decremented) and tested in a single thread-safe unbroken operation. It is specifically needed for reference counting in the handle classes.

See atomic_counter class index.


auto_COM_ptr

library: classics header: auto_COM_ptr.h usage: template, main API

*** docs in .txt file, needs to be added to the documentation base.


baro

library: classics header: pointers.h usage: template, main API

A reference-counted smart pointer for "weak references". See the handle class index for more information.


byte

library: classics header: common.h usage: main API

A typedef for unsigned char. This is meant for 8-bit data as a small integer, to distinguish it from character strings.


callback, exception

library: classics header: exception.h usage: main API

This abstract base class is used with the exception::register_callback class to provide automatic recording of data when an exception object is created. See the documentation for details.


can_handle

library: classics header: pointers.h usage: main API

Used as a base class, it provides a simple way to make an object capable of being used with the “handle” family of smart pointers. See XXXX [[XREF goes here]] in the handle Userís Guide for more information.


chdata

library: classics header: vararray.h usage: internal

This class is used internally by the vararray implementation.


cloaked_pointer

library: classics header: cloaked_pointer.h usage: template, main API

NEEDS DOCUMENTATION


close_Kernel_HANDLE

library: classics header: close_handle.h usage: main API

Define one of these to make a OS Kernel HANDLE behave as if it had a destructor which closes the handle when it goes out of scope.


closure_stdcall_to_thiscall

library: classics header: Classics/closure.h usage: internal

The magic part of dynamically creating a thunk, abstracted out of member_callback_thunk

See the Closure Documentation for more details.


commission

library: tomahawk header: commission.h usage: associated with message_parliament

A commission associates a minister with a sort-order and other information to speed up dispatching. The message_parliament contains an array of commissions, which is an ordered array of smart pointers to ministers that should try to handle a windows message.

See the commission class index for more information.

const_baro

library: classics header: pointers.h usage: template, main API

A reference-counted smart pointer for "weak references". See the handle class index for more information.


const_iterator

library: classics header: vararray.h usage: template, main API

This is used to iterate over vararray collections.

See Iterators in the Userís Guide, or the reference.


const_handle

library: classics header: pointers.h usage: template, main API

A reference-counted smart pointer. For more information, see handle class index.


cow

library: classics header: pointers.h usage: template, main API

A reference-counted smart pointer having Copy-On-Write semantics. For more information, see the handle class index or the cow User’s Guide.


critical_section

library: classics header: critical_section.h usage: main API

A simple mechanism for mutual exclusion, based on the NT CriticalSection mechanism.

See critical_section documentation.

See also class event_flag.


data_t

library: classics header: vararray.h usage: internal

This class is used by the vararray to manipulate the elements of the collection. This is an abstract class, containing virtual functions for coping, creating, and destroying elements. The derived classes s_data_t and g_data_t provide actual implementations.


debug_object_count_t

library: classics header: debug_object_count.h usage: debugging

This allows leaked objects to be reported automatically at program termination.


Dialog_message_tap

library: Tomahawk header: Dialog_message_tap.h usage: main API

This is derived from message_tap. It provides C++ class object control around model dialog boxes, modeless dialog boxes, and property page sheets.

See Dialog_message_tap documentation.


dimensional

library: classics header: dimensional.h usage: main API

A template used to create a dimentional quantity. An ordinary number could represent a number of feet or a number of seconds, but what does it mean to add them together? This template allows you to create Distance and Time as distinct types without loss of efficiency.

See dimensional documentation.


eagduru

library: tomahawk header: eagduru.h usage: main API

See eagduru class index for more information.


event_flag

library: classics header: event_flag.h usage: main API

This class encapsulates a Win32 event object. It shields the user from the raw system calls (and specifically prevents inclusion of RatWin headers), and provides robust error checking.

See event_flag documentation.

See also class critical_section.


exception

library: classics header: exception.h usage: main API

This is used to represent error conditions. An exception object is thrown to indicate an error. Note that classics::exception is derived from std::exception.

See exception class index for more information.


exception_value_logger

library: classics header: exception.h usage: main API

This parameterized class makes it simple to log named attributes when an exception object is created. It is called exception_value_logger rather than exception::value_logger because when this was written Microsoftís compiler didnít like templates declared inside classes.

See the documentation for details.


filename_t

library: classics header: filename.h usage: main API

This class represents a file name in a format that can be parsed and manipulated as a list of parts. It can handle either a PC file system name, a URL, or others.

See filename_t class index for more information.


filename_t_base

library: classics header: filename.h usage: implementation detail

This class is split out of filename_t to isolate the low-level features. This makes it simple to redo the underlying implementation of how parts are stored and parsed, without affecting the higher-level functionality. Splitting it up this way also helps define testing requirements.


filesystem_t

library: classics nested in: filename_t header: filename.h usage: advanced API

This abstract base class is used to provide details about the actual file system, and to customize the behavior of filename_t. See filename_t Userís Guide for more information.

Concrete types supplied are PC_filesystem_t and URL_filesystem_t.


fixed_auto_buffer

library: classics header: fixed_auto_buffer.h usage: main API

This class is used to provide auto (local variables allocated on the stack) arrays (or binary buffers) whose size is not known until run time. It has a low overhead compared to other collection-type classes.


flagword

library: classics header: flagword.h usage: template, main API

This parameterized class is used to create sets of flags, such as a bunch of options passed as a single parameter.

See flagword documentation.


foreign_window

library: tomahawk header: foreign_window.h usage: main API

This provides a concrete implementation of HWND_vpapa, XXXXX (other interfaces) to allow access to existing HWND objects.


g_data_t

library: classics header: vararray.h usage: template, internal

This template is a concrete class derived from data_t. It is instantiated by each vararray_g with the same type argument. That is, a vararray_g<complex> would use a g_data_t<complex> to match.


generic_2D_point

library: classics header: 2D_point.h, point_ios.h usage: template, main API

This is a 2-dimentional point. It is intended to provide common code for various flavors of ďpointsĒ needed, including long, short, and double.


generic_string

library: classics header: string.h usage: template, main API

This is a general string class. See string and wstring.

See generic_string documentation


handle

library: classics header: pointers.h usage: template, main API

A reference-counted smart pointer. See the handle class index for more information.


handle_structure

library: classics header: pointers.h usage: internal

This is a base class used to factor out common code from all the smart pointer templates, including handle, const_handle, cow, baro, and const_baro.


handle_structure_nt

library: classics header: pointers.h usage: internal

A non-template base class to bring out common code from the handle_structure class.


hsoft

library: ratwin header: base.h namespace: ratwin::base usage: template

This goes with the various Windows HANDLE types. It is a soft-typed HANDLE, allowing you to use the proper kind of HANDLE, or a generic untyped HANDLE, but not a known improper type of HANDLE.

Making a parameter of type HANDLE would accept any kind of HANDLE: Kernel_HANDLE, HMENU, HKEY, etc. That is usually too weakly typed, and defeats the purpose of having strong HANDLE types. But a parameter of type hsoft<HMENU> would allow you to pass a HMENU or a HANDLE only, and reject a HKEY, Kernel_HANDLE, and all the rest at compile time.


HWND_vpapa

library: tomahawk header: HWND_vpapa.h usage: advanced

This is a class that makes a correspondance between a C++ class w/reference counting, and a Windows HWND handle. It is a virtual base class of all the Tomahawk classes that provide functionality for a Window object.

See index for HWND_vpapa class documentation in the index pane.


hypothetical_trug

library: classics header: trug.h usage: template, advanced

This template lists the members that are required for a class to be a trug. It also provides some help in implementing them, so a derived class need do very little to create a trug class. The name hypothetical is used in the same manner as abstract. This is not abstract in the C++ sence because the members are not virtual. I use hypothetical for template metaprogramming in the same sence as abstract or interface is for run-time polymorphism.

For more information, see the section in the trug Userís Guide.


index_t

library: classics nested in: filename_t header: filename_t.h usage: internal

This is used by the filename_t to index the various ďpartsĒ of the string it is holding.


intermediate

library: classics header: vararray.h usage: internal

This class is used internally by the vararray implementation.


iterator (global)

library: classics header: vararray.h usage: main API

This is used to iterate over vararray collections.

See Iterators in the Vararray Userís Guide, or the Iterator Reference.

See also const_iterator.


iterator (exception::iterator)

library: classics nested in: exception header: exception.h usage: main API

This is used to easily access the information in an exception object. See the documentation for details.


launch_thread

library: classics header: thread.h usage: template, main API

Provides an easy way to start a thread. See the documentation page for this class.


lifetime

library: classics header: pointers.h usage: protected or advanced API


make_alias_t

library: classics header: vararray.h usage: internal

This is a dummy type used only to define the make_alias constant.

See Reference Counting—COW or alias in the vararray Userís Guide.


member_callback_thunk

library: classics header: Classics/closure.h usage: public

Generates a __stdcall function that supplies a this pointer and jumps to a member function.

See the Closure Documentation for more details.


message_tap

library: Tomahawk header: Tomahawk\message_tap.h usage: main API

This class provides a WinProc that adds a this pointer and calls a virtual function on a C++ object.

See index for message_tap class documentation in the index pane.


message_parliament

library: Tomahawk header: Tomahawk\message_parliament.h usage: main API

This class dispatches window messages to components that encapsulate small units of functionality. It works with other "mix-in" classes to form complete window implementations with high granularity and potential for customization.

See index for message_parliament documentation in the index pane.


message_range

library: Tomahawk header: Tomahawk\message_range.h usage: main API

description...

See discussion of this class in the message_parliament Userís Guide.


MFC_CString

library: classics header: MFC_CString.h usage: internal

This is a stand-in for the MFC CString classes. It exists here so that Classics is not dependant on the MFC libraries, and because CString as defined in AFX.h uses conditional compilation and cannot handle 8-bit and 16-bit strings in the same program.

The internal structure and memory management matches CStringís, and there is only enough code supplied to do what ustring needs of it. This allows ustring to translate to and from either flavor of CString.

The header file uses conditional compilation to route the ::CString type to either Classics::MFC_CString<char> or Classics::MFC_CString<wchar_t> depending on the state of the _UNICODE preprocessor symbol. However, the same Classics DLL supports both Unicode and non-Unicode versions, and doesnít care whether youíre using MFC in a DLL or as a static library. The single Classics.DLL handles all cases.

For more information, see CString Support in the ustring documentation.


minister

library: Tomahawk header: Tomahawk\minister.h usage: main API

description...

See index for minister documentation in the index pane.


MSG

library: RatWin header: message=struct.h or message.h namespace: ratwin::message usage: public

This is the same structure as defined in WINDOWS.H with that name.

See also sMSG.


no_auto_copy

library: classics header: no_auto_copy.h usage: main API

This implements the idiom of making a class not have an automatically-generated copy constructor or copy assignment operator. You can derive from this class rather than defining the dummy functions directly.


noisy1

library: classics header: debug.h usage: debugging

This is used as a base class to make an object announce its construction and destruction.


nt_base

library: classics header: vararray.h usage: internal

This class is a non-template base class to factor out common code in the vararray template.


OleItemContainer_impl

library: classics header: COM\OleItemContainer_impl.h usage: main API

This is a starter implementation for supporting the IOleItemContainer interface.


PC_filesystem_t

library: classics header: filename.h usage: advanced API

This concrete class is derived from filesystem_t and provides details on the parsing of file names and manipulation of the file system. An instance to this class is provided in the static member filename_t::PC_filesystem.


peremptory

library: classics header: peremptory.h usage: main API

peremptory: \Per"emp*to*ry\ Not allowing contradiction or refusal; imperative. This template is used to ensure that a global variable is constructed either at first use (thus avoiding the static constructor ordering issues), or still initialized before main() even if not used before then.

This is particulary necessary for mutual exclusion control objects, since they must be initialized before theading starts or you need another control object to control access to it while creating it, ad infinitum. No additional threads can be started during global construction phase before main() is called, so this fills that purpose.


pool_mixin

library: classics header: fixed_memory_pool.h usage: main API, deprecated

A helper class for ease of using the static_fixed_memory_pool. See fixed memory pool documentation.


profile_timer

library: classics header: profile_timer.h usage: main API

A mechanism for timing regions of code. It measures thread time, not wall-clock time, so itís primarily used to profile code.

See profile_timer documentation.


prothonotary

library: classics header: COM\prothonotary.h usage: main API

This registers and unregisters a COM server.

See prothonotary documentation.


register_callback, exception

library: classics header: exception.h usage: main API

This classís constructor registers an exception::callback, and its destructor revokes it. See the documentation for details.


registry_key

library: classics header: registry.h usage: main API

...
See the documentation for details.


s_data_t

library: classics header: vararray.h usage: internal

This is a concrete form of the data_t class (see above) thatís used with the vararray_s. Unlike g_data_t, this class is not a template and a single implementation is shared among all species of vararray_s.


schedule_t

library: classics header: schedule_t.h usage: main API

This enumeration holds a priority value. 16 bits are used to provide for fine-grained control. High bits (in a 32-bit word) are used as flags.


sMSG

library: RatWin header: message=struct.h or message.h usage: public

This is a simple message structure used to hold the items normally passed to WinProc (and related) callback functions: hwnd, message, wParam, and lParam.

This isnít called MSG because WINDOWS.H already defines that name as a larger structure, so RatWin uses MSG for the same purpose.

The sMSG struct and the specific message-cracker structs are described in the RatWin Message Cracker documentation.


snoop_t

library: classics header: vararray.h usage: debugging

This data structure is used with the debug_snoop function to spy on the internal state of the vararray.


static_fixed_memory_pool

library: classics header: fixed_memory_pool.h usage: main API

Efficient small block allocation, including support for global static objects. See fixed memory pool documentation.


string

library: classics header: string.h, string_ios.h usage: main API

This is a typedef for generic_string<char>. It is a string of 8-bit characters.

See string documentation


trug

library: classics header: trug.h usage: template, main API

A trug is a general container. It holds something else. The term trug can be used to refer to any concrete implementation of the proper interface (see hypothetical_trug), and the actual template named trug has a few supplied specializations.

A trug of a pointer type, e.g. trug<int*>, provides strict ownership semantics and automatic destruction for pointers, similarly to the standard std::auto_ptr class.

A trug of a Windows HANDLE type provides strict ownership and automatic destruction in an analogous way to the pointers. For example, trug<HKEY> knows to call the Win32 API function RegCloseKey when “freed”.

See the trug documentation index for details.


tristate

library: classics header: misc_types.h usage: main API

Used for 3-value logic, particularly in representing userís settings. Values are Yes and No for normal logic, plus a third state which can be called either Maybe or Automatic.


ts_pool_mixin

library: classics header: fixed_memory_pool.h usage: main API

A helper class for ease of using the static_fixed_memory_pool. See fixed memory pool documentation.


ts_static_fixed_memory_pool

library: classics header: fixed_memory_pool.h usage: main API

A thread-safe version of static_fixed_memory_pool. See fixed memory pool documentation.


ulong

library: classics header: common.h usage: main API

A typedef for unsigned long.


URL_filesystem_t

library: classics header: filename.h usage: advanced API

This concrete class is derived from filesystem_t and provides details on the parsing of Universal Resource Locator names and limited manipulation of the network space as a filesystem. An instance to this class is provided in the static member filename_t::URL_filesystem.


ushort

library: classics header: common.h usage: main API

A typedef for unsigned short.


ustring

library: classics header: ustring.h usage: main API

This is a universal string. It can be either a wide or narrow string, reducing the number of signatures when functions need to take either. It also serves to translate between wide and narrow strings, and to translate between string classes from any library.

see ustring documentation.


vararray

library: classics header: vararray.h usage: main API, abstract base

The vararray template is the primary ďarray-likeĒ collection class. It is an abstract base class holding the bulk of the implementation, with concrete derived templates vararray_s and vararray_g (see below) used in actual variable definitions.

see reference or Userís Guide.


vararray_g

library: classics header: vararray.h usage: template, main API

This template is for variable-sized arrays in the general case (_g for general). Specifically, it does handle elements with constructors and destructors.

see reference or Userís Guide for the general vararray class.


vararray_s

library: classics header: vararray.h usage: template, main API

This template is a more efficient streamlined vararray for the special case when the element is a simple type (_s for simple). Specifically, it uses memcpy to move elements around, and performs no special initialization or cleanup. Contrast with vararray_g above.

see reference or Userís Guide for the general vararray class.


win_exception

library: classics header: exception.h usage: main API

This is derived from classics::exception. It is used for Win32 errors, as it knows about GetLastError and how to look up the description for an error code.


WNDPROC_2

library: ratwin header: window=struct.h namespace: ratwin::window usage: main API

This is the same as a WNDPROC, except it is declared to take a sMSG structure instead of four separate arguments.

typedef long (__stdcall* WNDPROC_2)(message::sMSG);

WNDPROC_sig

library: ratwin header: window=struct.h namespace: ratwin::window usage: main API

This is a type that abstracts out the actual signature used for a WndProc. It can be either a WNDPROC or a WNDPROC_2.


wstring

library: classics header: string.h, string_ios.h usage: main API

This is a typedef for generic_string<wchar_t>. It is a string of 16-bit characters.

See wstring documentation


xwstring

library: classics header: string.h, string_ios.h usage: main API

This is a typedef for generic_string<unsigned __int32>. It is a string of 32-bit characters.

See xwstring documentation