| Address_map | An Address_map is a generalized two-level hierarchical map of virtual addresses to some corresponding values |
| Array< T > | Array is a simple growable list container implemented as an array |
| Block_device | This is an abstract block device, implemented by things like disk drivers |
| Block_map | A block map associates virtual addresses with their corresponding block locations on disk |
| compare< Key > | This is an abstract value comparison class that you can treat as a function |
| compare< char * > | Given two character strings and a size, this class compares them for equality |
| compare< const char * > | Given two const character strings and a size, this class compares them for equality |
| compare< void * > | Given two pointers and a size, this class compares them for equality |
| Console | Represents a console that accepts user input one line at a time |
| DMA_buffer | DMA_buffer is currently just a single page of physical memory allocated under the one megabyte mark that can be transfered via DMA |
| Floppy | This is the floppy disk driver |
| Handler_registers | This struct encapsulates the register information available within interrupt handlers |
| hash< Key > | This is an abstract data hashing class that you can treat as a function |
| hash< char * > | Given a character string, this class calculates a hash value |
| hash< const char * > | Given a constant character string, this class calculates a hash value |
| hash< void * > | Given a pointer, this class calculates a hash value for the pointer itself |
| Hash_iterator< Key, Value > | A Hash_iterator allows iterating over the elements of a Hash_table |
| Hash_node< Key, Value > | A hash_node is a key/value pair stored within a hash table |
| Hash_table< Key, Value, Hash_func, Compare_func > | This is a basic non-growable hash table that maps keys to values |
| Int_descriptor | Int_descriptor is a single entry in the interrupt descriptor table (IDT) |
| Int_handler | This class encapsulates a single interrupt handler function |
| Interrupts | This class represents the interrupt descriptor table (IDT), and allows callers to register and unregister interrupt handlers |
| Key_event | A keypress or release, potentially with modifiers |
| Keyboard | This is an abstract keyboard device, implemented by keyboard drivers |
| List< Type > | This class is a basic doubly linked list, with the node metadata actually stored in each element |
| List_iterator< Type > | A List_iterator allows iterating over the elements of a given List |
| List_node | A List_node is a node in a linked List |
| Mapping_cache_info | Metadata on mappings within the temporary mapping cache |
| Page | A Page is not actually a single page, but rather a contiguous range of pages such that the number of pages in the range is a power of two |
| Page_allocator | Page_allocator is the allocator/deallocator for whole pages or ranges of pages |
| Page_map | The Page_map includes the page directory and all of the page tables |
| Pc_keyboard | An implementation of the Keyboard class, representing a PS/2 or AT keyboard using the motherboard's keyboard controller |
| Physical_memory | The Physical_memory map keeps track of which physical memory pages are available for allocation |
| PIC | The PIC is the programmable interrupt controller |
| Scheduler | The Scheduler manages all active tasks and is responsible for switching between them to provide software multitasking |
| Screen | Screen is the VGA color screen buffer |
| Segment | This class contains information about a storage segment on disk |
| Segment_header | The first disk block of a segment is a segment header containing an array of virtual addresses for all the pages stored within the segment |
| Segment_map | A segment map associates segment index numbers with their corresponding page counts (the number of pages a segment contains) |
| Semaphore | This is your classic semaphore, used to implement synchronization between tasks |
| Shell | A basic Torsion command shell |
| Slab | A Slab is a page of memory that contains slab objects all of the same size |
| Slab_allocator | A Slab_allocator is responsible for managing several slabs that have the same slab object size |
| Slab_object | Slab_object is a chunk of memory within a slab |
| Spinlock | A Spinlock allows locking of a section of code so that multiple processors cannot run it simultaneously |
| Storage_system | A storage system is simply a file system that stores pages of memory instead of files |
| Superblock | A Superblock records the completion of a checkpoint |
| Task | A Task instance includes the stack and state information for an individual task |
| Test_case | A Test_case is a set of one or more unit tests, usually responsible for testing a single class |
| Test_suite< Test_case_type > | A Test_suite is actually responsible for running a collection of tests |
| Timer | Responsible for managing the hardware timer and all timer callback events |
| Timer_callback | A timer callback is basically a periodic event |
| Virtual_memory | Virtual_memory is the allocator/deallocator for virtual memory |
Torsion Operating System, Copyright (C) 2000-2004 Dan Helfman