docs/user/support/support_intro.dox

   1 /*
   2  * Copyright 2007-2010 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              Nicolas de Leon, insdel@haqr.net
   7  *              Niels Sascha Reedijk, niels.reedijk@gmail.com
   8  */
   9
  10
  11 /*!
  12         \page support_intro Introduction to the Support Kit
  13
  14         The Support Kit provides a handy set of classes that you can use in your
  15         applications. These classes provide:
  16         - \b Thread \b Safety. Haiku can execute multiple threads of an application
  17                 in parallel, letting certain parts of an application continue when one part
  18                 is stalled, as well as letting an application process multiple pieces of
  19                 data at the same time on multicore or multiprocessor systems. However,
  20                 there are times when multiple threads desire to work on the same piece of
  21                 data at the same time, potentially causing a conflict where variables or
  22                 pointers are changed by one thread causing another to execute incorrectly.
  23                 To prevent this, Haiku implements a \"locking\" mechanism, allowing one
  24                 thread to \"lock out\" other threads from executing code that might modify
  25                 the same data.
  26         - \b Archiving \b and \b IO. These classes allow a programmer to convert
  27                 objects into a form that can more easily be transferred to other
  28                 applications or stored to disk, as well as performing basic input and
  29                 output operations.
  30         - \b Memory \b Allocation. This class allows a programmer to hand off some of
  31                 the duties of memory accounting and management.
  32         - \b Common \b Datatypes. To avoid unnecessary duplication of code and to
  33                 make life easier for programmers, Haiku includes classes that handle
  34                 management of ordered lists and strings.
  35
  36         There are also a number of utility functions to time actions, play system
  37         alert sounds, compare strings, and atomically manipulate integers. Have a
  38         look at the overview, or go straight to the complete
  39         \link support list of components \endlink of this kit.
  40
  41         \section Overview
  42         - Thread Safety:
  43                 - BLocker provides a semaphore-like locking mechanism allowing for
  44                         recursive locks.
  45                         - BAutolock provides a simple method of automatically removing a lock
  46                                 when a function ends.
  47                 - \ref TLS.h "Thread Local Storage" allows a global variable\'s content to
  48                         be sensitive to thread context.
  49         - Archiving and IO:
  50                 - BArchivable provides an interface for \"archiving\" objects so that they
  51                         may be sent to other applications where an identical copy will be
  52                         recreated.
  53                         - BArchiver simplifies archiving of BArchivable hierarchies.
  54                         - BUnarchiver simplifies unarchiving hierarchies that have been archived
  55                                 using BArchiver.
  56                 - BFlattenable provides an interface for \"flattening\" objects so that
  57                     they may be easily stored to disk.
  58                 - BDataIO provides an interface for generalized read/write streams.
  59                         - BPositionIO extends BDataIO to allow seeking within the data.
  60                                 - BBufferIO creates a buffer and attaches it to a BPositionIO stream,
  61                                         allowing for reduced load on the underlying stream.
  62                                 - BMemoryIO allows operation on an already-existing buffer.
  63                                 - BMallocIO creates and allows operation on a buffer.
  64         - Memory Allocation:
  65                 - BBlockCache allows an application to allocate a \"pool\" of memory blocks
  66                         that the application can fetch and dispose of as it pleases, letting the
  67                         application make only a few large memory allocations, instead of many
  68                         expensive small allocations.
  69         - Common Datatypes:
  70                 - BList allows simple ordered lists and provides common access,
  71                         modification, and comparison functions.
  72                 - BString allows strings and provides common access, modification, and
  73                         comparison functions.
  74         - BStopWatch allows an application to measure the time an action takes.
  75         - \ref support_globals "Global functions"
  76         - \ref TypeConstants.h "Common types and constants"
  77         - Error codes for all kits
  78 */
  79
  80
  81 // Short listing of documents that belong to this module so that people can
  82 // find these from the module overview.
  83 // This should become standardized in Doxygen though. There is an item on
  84 // the todo list on this.
  85
  86
  87 /*!
  88         \addtogroup support
  89
  90         For a better overview, have a look at \ref support_intro .
  91 */