click to put Class Index into the index pane click to put Class Index into the index pane
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.
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.
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.
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.
library: classics header: auto_COM_ptr.h usage: template, main API
*** docs in .txt file, needs to be added to the documentation base.
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.
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.
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.
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.
library: classics header: vararray.h usage: internal
This class is used internally by the vararray implementation.
library: classics header: cloaked_pointer.h usage: template, main API
NEEDS DOCUMENTATION
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.
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.
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.
commission class index for more information.
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.
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.
library: classics header: pointers.h usage: template, main API
A reference-counted smart pointer. For more information, see handle class index.
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.
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.
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.
library: classics header: debug_object_count.h usage: debugging
This allows leaked objects to be reported automatically at program termination.
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.
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.
library: tomahawk header: eagduru.h usage: main API
See eagduru class index for
more information.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
library: classics header: string.h usage: template, main API
This is a general string class. See string and
wstring.
See generic_string documentation
library: classics header: pointers.h usage: template, main API
A reference-counted smart pointer. See the
handle class index for more information.
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.
library: classics header: pointers.h usage: internal
A non-template base class to bring out common code from the handle_structure class.
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.
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.
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.
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.
library: classics header: vararray.h usage: internal
This class is used internally by the vararray implementation.
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.
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.
library: classics header: thread.h usage: template, main API
Provides an easy way to start a thread. See the documentation page for this class.
library: classics header: pointers.h usage: protected or advanced API
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.
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.
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.
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.
library: Tomahawk header: Tomahawk\message_range.h usage: main API
description...
See discussion of this class in the message_parliament User’s Guide.
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.
library: Tomahawk header: Tomahawk\minister.h usage: main API
description...
See index for minister documentation in the index pane.
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.
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.
library: classics header: debug.h usage: debugging
This is used as a base class to make an object announce its construction and destruction.
library: classics header: vararray.h usage: internal
This class is a non-template base class to factor out common code in the vararray template.
library: classics header: COM\OleItemContainer_impl.h usage: main API
This is a starter implementation for supporting the IOleItemContainer interface.
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.
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.
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.
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.
library: classics header: COM\prothonotary.h usage: main API
This registers and unregisters a COM server.
See prothonotary documentation.
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.
library: classics header: registry.h usage: main API
...
See the documentation for details.
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.
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.
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.
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.
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.
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
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.
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.
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.
library: classics header: fixed_memory_pool.h usage: main API
A thread-safe version of static_fixed_memory_pool. See fixed memory pool documentation.
library: classics header: common.h usage: main API
A typedef for unsigned long.
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.
library: classics header: common.h usage: main API
A typedef for unsigned short.
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.
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.
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.
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.
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.
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);
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.
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
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