Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 123456]

►Nboost	Boost library
►NHyperspace	Hyperspace definitions
►NHsParser
►CParser
Cdefinition
CParserState
Cset_any_string
Cset_as_commands
Cset_command
Cset_dir_name
Cset_event_mask
Cset_file_name
Cset_help
Cset_last_attr
Cset_last_attr_name
Cset_last_attr_size
Cset_last_attr_value
Cset_locate_type
Cset_lock_mode
Cset_node_name
Cset_open_flag
Cset_outfile
Cset_recursive
CAttribute	Holds extended attribute and value
CBDbHandles	Manages namespace and transient state database handles
CBDbTxn	Manages transaction state
CBerkeleyDbFilesystem	Hyperspace filesystem implementation on top of BerkeleyDB
CClientConnectionHandler
CClientHandleState
CClientKeepaliveHandler
CDbtManaged
CDirEntry
CDirEntryAttr
CEvent
CEventLockAcquired
CEventLockGranted
CEventLockReleased
CEventNamed
CFileHandleCallback
CHandleCallback
CHsCommandInterpreter
CHsHelpText
CLockRequest	Encapsulates a lock request for a file node
CLockSequencer
CLtDirEntry
CLtDirEntryAttr
CLtSessionData
►CMaster
CCommandContext
CEventContext
CMetricsHandler	Collects and publishes Hyperspace metrics
CNotification
CProtocol	Protocol driver for encoding request messages
CReplicationInfo	Encapsulates replication state
CRequestHandlerAttrDel	Unmarshalls request parameters and calls Master::attr_del()
CRequestHandlerAttrExists	Unmarshalls request parameters and calls Master::attr_exists()
CRequestHandlerAttrGet
CRequestHandlerAttrIncr
CRequestHandlerAttrList
CRequestHandlerAttrSet
CRequestHandlerClose
CRequestHandlerDelete
CRequestHandlerDestroySession
CRequestHandlerDoMaintenance
CRequestHandlerExists
CRequestHandlerExpireSessions
CRequestHandlerHandshake
CRequestHandlerLock
CRequestHandlerMkdir
CRequestHandlerOpen
CRequestHandlerReaddir
CRequestHandlerReaddirAttr
CRequestHandlerReadpathAttr
CRequestHandlerRelease
CRequestHandlerRenewSession
CRequestHandlerShutdown
CRequestHandlerStatus
CResponseCallbackAttrExists	Sends back result of an attr_exists request
CResponseCallbackAttrGet	Sends back result of an attr_get request
CResponseCallbackAttrIncr
CResponseCallbackAttrList
CResponseCallbackExists
CResponseCallbackLock
CResponseCallbackOpen
CResponseCallbackReaddir
CResponseCallbackReaddirAttr
CResponseCallbackReadpathAttr
CResponseCallbackStatus
CServerConnectionHandler
CServerKeepaliveHandler
CSession	Hyperspace session
CSessionCallback	A callback object derived from this class gets passed into the constructor of Hyperspace
CSessionData
►NHypertable	Hypertable definitions
►N__detail
C__any
C__nat
C__swappable
►NApps
CRangeServer
►NClusterDefinition
CClusterDefinition	Represents a cluster definition
►NClusterDefinitionFile	Cluster definition file translation definitions
CCompiler	Compiles a cluster definition file into an executable bash script
CToJson	Compiles a cluster definition file into an executable bash script
CToken	Cluster definition file token
CTokenizer	Splits cluster definition file into tokens
CTranslationContext	Context used to translate cluster definition statements
CTranslator	Abstract base class for translators
CTranslatorCode	Translates a code block
CTranslatorRole	Translates a role definition
CTranslatorTask	Translates a task definition
CTranslatorVariable	Translates a variable definition
►NConfig
CClientPolicy
CCommPolicy	Config policy for Comm layer
CCons	Helpers to compose init policies; allow to combine two policies into one
CCons< NullPolicy, PolicyT >
CDefaultPolicy	Default init policy
CFsBrokerPolicy	Mutually exclusive with GenericServerPolicy
CFsClientPolicy
CGenericServerPolicy	Config policy for generic Comm layer server
CHyperspaceClientPolicy
CHyperspaceCommandShellPolicy
CHyperspaceMasterPolicy
CJoin
CMasterClientPolicy
CNullPolicy
CPolicy	Interface and base of config policy
CRangeServerClientPolicy
CRangeServerPolicy
CTestPolicy	A Policy class for extending command line options
CThriftBrokerPolicy	Mutually exclusive with GenericServerPolicy
CThriftClientPolicy
►NFsBroker	File system broker definitions
►NLib	File system broker framework and client library
►NRequest
►NHandler
CAppend	Application handler for append function
CClose	Application handler for close function
CCreate	Application handler for create function
CDebug	Application handler for debug function
CExists	Application handler for exists function
CFactory	Factory class for constructing application handlers from request events
CFlush	Application handler for flush function
CLength	Application handler for length function
CMkdirs	Application handler for mkdirs function
COpen	Application handler for open function
CPread	Application handler for pread function
CRead	Application handler for read function
CReaddir	Application handler for readdir function
CRemove	Application handler for remove function
CRename	Application handler for rename function
CRmdir	Application handler for rmdir function
CSeek	Application handler for seek function
CStatus	Application handler for status function
CSync	Application handler for sync function
►NParameters
CAppend	Request parameters for append requests
CClose	Request parameters for close requests
CCreate	Request parameters for create requests
CDebug	Request parameters for debug requests
CExists	Request parameters for exists requests
CFlush	Request parameters for flush requests
CLength	Request parameters for length requests
CMkdirs	Request parameters for mkdirs requests
COpen	Request parameters for open requests
CPread	Request parameters for pread requests
CRead	Request parameters for read requests
CReaddir	Request parameters for readdir requests
CRemove	Request parameters for remove requests
CRename	Request parameters for rename requests
CRmdir	Request parameters for rmdir requests
CSeek	Request parameters for seek requests
CShutdown	Request parameters for shutdown requests
CSync	Request parameters for sync requests
►NResponse
►NCallback
CAppend	Application handler for append function
CExists	Application handler for exists function
CLength	Application handler for length function
COpen	Application handler for open function
CRead	Application handler for read function
CReaddir	Application handler for readdir function
CStatus	Application handler for open function
►NParameters
CAppend	Response parameters for append requests
CExists	Response parameters for exists requests
CLength	Response parameters for length requests
COpen	Response parameters for open requests
CRead	Response parameters for read requests
CReaddir	Response parameters for readdir requests
CStatus	Response parameters for open requests
CBroker	Abstract class to be implemented by brokers
CClient	Proxy class for FS broker
CClientBufferedReaderHandler
CConnectionHandler	Connection handler for file system brokers
CConnectionHandlerFactory	This class serves as the connection handler factory
►CFileDevice
Ccategory
Cimpl
►CFileSink
Ccategory
►CFileSource
Ccategory
CMetricsHandler	Collects and publishes FsBroker metrics
COpenFileData
COpenFileMap
CStatusManager	Manages file system broker status
CCephBroker
CLocalBroker
CMaprBroker
COpenFileDataCeph
COpenFileDataCephPtr
COpenFileDataLocal
COpenFileDataLocalPtr
COpenFileDataMapr
COpenFileDataMaprPtr
COpenFileDataQfs
COpenFileDataQfsPtr
CQfsBroker
►NHql
Caccess_group_add_column_family
Cadd_column
Cadd_insert_value
Cadd_range_move_spec
Cbalance_set_duration
CCellInterval
Cclose_access_group
Cclose_column_family
Ccreate_index
Ccreate_qualifier_index
Cdelete_column
Cdelete_set_row
Cdrop_column_family
Cdrop_qualifier_index
Cdrop_value_index
Cfinish_alter_table_statement
Cfinish_create_table_statement
CInsertRecord
Copen_access_group
Copen_column_family
Copen_existing_column_family
►CParser
Cdefinition
CParserState
CRowInterval
Cscan_add_column_family
Cscan_add_column_qualifier
Cscan_add_row_interval
Cscan_clear_display_timestamps
Cscan_set_boolop
Cscan_set_buckets
Cscan_set_cell_column
Cscan_set_cell_limit
Cscan_set_cell_limit_per_family
Cscan_set_cell_offset
Cscan_set_cell_row
Cscan_set_column_predicate_name
Cscan_set_column_predicate_operation
Cscan_set_column_predicate_qualifier
Cscan_set_column_predicate_value
Cscan_set_day
Cscan_set_decimal_seconds
Cscan_set_display_revisions
Cscan_set_display_timestamps
Cscan_set_hours
Cscan_set_keys_only
Cscan_set_max_versions
Cscan_set_minutes
Cscan_set_month
Cscan_set_nanoseconds
Cscan_set_no_cache
Cscan_set_outfile
Cscan_set_relop
Cscan_set_return_deletes
Cscan_set_row
Cscan_set_row_limit
Cscan_set_row_offset
Cscan_set_row_regexp
Cscan_set_scan_and_filter_rows
Cscan_set_seconds
Cscan_set_time
Cscan_set_value_regexp
Cscan_set_year
CScanState
Cset_balance_algorithm
Cset_blocksize
Cset_bloom_filter
Cset_clone_table_name
Cset_command
Cset_compressor
Cset_counter
Cset_delete_timestamp
Cset_delete_version_timestamp
Cset_destination
Cset_dup_key_cols
Cset_dup_key_cols_true
Cset_field_separator
Cset_flags_compaction_type
Cset_flags_index_type
Cset_flags_range_type
Cset_group_commit_interval
Cset_header_file
Cset_help
Cset_if_exists
Cset_ignore_unknown_cfs
Cset_in_memory
Cset_input_file
Cset_insert_columnkey
Cset_insert_rowkey
Cset_insert_rowkey_call
Cset_insert_timestamp
Cset_insert_value
Cset_insert_value_call
Cset_max_versions
Cset_modify_flag
Cset_namespace
Cset_new_table_name
Cset_no_log
Cset_noescape
Cset_nokeys
Cset_output_file
Cset_range_end_row
Cset_range_start_row
Cset_rangeserver
Cset_rename_column_family_new_name
Cset_rename_column_family_old_name
Cset_replay
Cset_replication
Cset_row_uniquify_chars
Cset_scanner_id
Cset_single_cell_format
Cset_source
Cset_str
Cset_table_name
Cset_tables_only
Cset_time_order
Cset_timestamp_column
Cset_ttl
Cset_variable_name
Cset_variable_value
Cset_with_ids
Cstart_alter_table
Cstart_create_table_statement
►NLib	Hypertable library
►NMaster
►NRequest
►NParameters
CAlterTable	Request parameters for alter table operation
CBalance	Request parameters for balance operation
CCompact	Request parameters for compact operation
CCreateNamespace	Request parameters for create namespace operation
CCreateTable	Request parameters for create table operation
CDropNamespace	Request parameters for drop namespace operation
CDropTable	Request parameters for drop table operation
CFetchResult	Request parameters for fetch result request
CMoveRange	Request parameters for move range operation
CPhantomCommitComplete	Request parameters for phantom commit complete operation
CPhantomPrepareComplete	Request parameters for phantom prepare complete operation
CRecreateIndexTables	Request parameters for recreate index tables operation
CRegisterServer	Request parameters for register server operation
CRelinquishAcknowledge	Request parameters for relinquish acknowledge operation
CRenameTable	Request parameters for rename table operation
CReplayComplete	Request parameters for replay complete operation
CReplayStatus	Request parameters for replay status operation
CSetState	Request parameters for set state operation
CStop	Request parameters for stop function
►NResponse
►NParameters
CRegisterServer	Response parameters for register server operation
CStatus	Response parameters for status operation
CSystemStatus	Response parameters for status operation
CClient	Client interface to Master
CClientHyperspaceSessionCallback
CEventHandlerMasterChange
CHyperspaceCallback
CNamespaceFlag	Namespace operation bit flags
CProtocol
►NRangeServer
►NRequest
►NParameters
CAcknowledgeLoad	Request parameters for acknowledge load function
CCommitLogSync	Request parameters for commit log sync function
CCompact	Request parameters for compact function
CCreateScanner	Request parameters for create scanner function
CDestroyScanner	Request parameters for destroy scanner function
CDropRange	Request parameters for drop range function
CDropTable	Request parameters for drop table function
CDump	Request parameters for dump function
CDumpPseudoTable	Request parameters for dump pseudo table function
CFetchScanblock	Request parameters for fetch scanblock function
CGetStatistics	Request parameters for get statistics function
CHeapcheck	Request parameters for heapcheck function
CLoadRange	Request parameters for load range function
CPhantomCommitRanges	Request parameters for phantom commit ranges function
CPhantomLoad	Request parameters for phantom load function
CPhantomPrepareRanges	Request parameters for phantom prepare ranges function
CPhantomUpdate	Request parameters for phantom update function
CRelinquishRange	Request parameters for relinquish range function
CReplayFragments	Request parameters for replay fragments function
CSetState	Request parameters for set state function
CTableMaintenanceDisable	Request parameters for table maintenance disable function
CTableMaintenanceEnable	Request parameters for table maintenance enable function
CUpdate	Request parameters for update function
CUpdateSchema	Request parameters for update schema function
►NResponse
►NParameters
CAcknowledgeLoad	Response parameters for acknowledge load function
CCreateScanner	Response parameters for acknowledge load function
CGetStatistics	Response parameters for get statistics function
CStatus	Response parameters for open requests
CClient	Client interface to RangeServer
CProtocol	Master client protocol information
►NRangeServerRecovery
CFragmentReplayPlan	Fragment replay plan
CFragmentReplayPlanById
CFragmentReplayPlanByLocation
CPlan	RangeServer recovery plan
CReceiverPlan	RangeServer recovery receiver plan
CReplayPlan	Holds a fragment replay plan for the recovery of a RangeServer
CServerReceiverPlan	Server receiver plan
CServerReceiverPlanByLocation
CServerReceiverPlanByRange
►NRS_METRICS	Facilities for reading and writing sys/RS_METRICS table
CRangeMeasurement	Single range metrics measurement
CRangeMetrics	Aggregates metrics for an individual range
CReader	Interface class for reading RangeServer metrics
CReaderTable	Reads metrics from the sys/RS_METRICS table
CServerMeasurement	Single server metrics measurement
CServerMetrics	Aggregates metrics for an individual RangeServer
CCellInterval	Represents a cell interval
CColumnPredicate	Represents a column predicate (e.g
CRowInterval	Represents a row interval
CScanCells	This class takes allows vector access to a set of cells contained in an EventPtr without any copying
CScanLimitState	Tracks row and cell limits used to enforce scan limit predicates
CScanSpec	Scan predicate and control specification
CScanSpecBuilder	Helper class for building a ScanSpec
►NLogger	Logging framework
CLogWriter	Writes to stdout
►NMaintenanceFlag	Maintenance task bit field
CEqual	Equality function for pointers
CHash	Hash function class for pointers
CMap	Maps object pointers to bit fields
►NMaster
CHyperspaceMasterFile	Facilitates operations on the master file in Hyperspace
►NMetaLog	MetaLog framework
CDefinition	Defines the set of valid MetaLog entities for a server
CDefinitionMaster
CDefinitionRangeServer
CEntity	Base class for MetaLog entities
CEntityHeader	Entity header
CEntityRecover	Recover entity used for sanity checking
CEntityTask
CEntityTaskAcknowledgeRelinquish
CHeader	Metalog file header
CReader	Reads a MetaLog
►CWriter	Writes a MetaLog
CWriteScheduler	Periodically flushes deferred writes to disk
►NRangeServer
►NRequest
►NHandler
CAcknowledgeLoad
CCommitLogSync
CCompact
CCreateScanner
CDestroyScanner
CDoMaintenance
CDropRange
CDropTable
CDump
CDumpPseudoTable
CFetchScanblock
CGetStatistics	Decodes "get statistics" request and calls RangeServer::get_statistics()
CGroupCommit
CHeapcheck
CLoadRange
CMetadataSync
CPhantomCommitRanges
CPhantomLoad
CPhantomPrepareRanges
CPhantomUpdate
CRelinquishRange
CReplayFragments
CSetState	Decodes set state request and calls RangeServer::set_state()
CShutdown
CStatus
CTableMaintenanceDisable	ApplicationHandler class for carrying out a RangeServer::table_maintenance_disable() request
CTableMaintenanceEnable	ApplicationHandler class for carrying out a RangeServer::table_maintenance_enable() request
CUpdate
CUpdateSchema
CWaitForMaintenance
►NResponse
►NCallback
CAcknowledgeLoad
CCreateScanner
CGetStatistics
CPhantomUpdate
CStatus	Response callback for status function
CUpdate
CConnectionHandler
►NSystemVariable
CSpec	Holds a variable code and boolean value
►NThrift
CClient	A client for the ThriftBroker
CClientHelper
►NThriftBroker
CContext
CHqlCallback
CScannerInfo
►CServerHandler
CStatistics
CServerHandlerFactory
CSharedMutatorMapKey
CThriftBrokerIfFactory
►C__directory_iterator
C__subdirectory_iterator
►C__directory_node_internal
Cpointer_compare
C__is_nothrow_swappable
C__is_nothrow_swappable_imp
C__is_nothrow_swappable_imp< false, _Tp >
C__is_swappable
►CAccessGroup	Access group
CCellStoreMaintenanceData
CHints
CMaintenanceData
CAccessGroupGarbageTracker	Tracks access group garbage and signals when collection is needed
CAccessGroupHintsFile	Reads and writes access group "hints" file
CAccessGroupOptions	Specification for access group options
CAccessGroupSpec	Access group specification
CAllocatorBase	Base classes for all Allocator classes
CAllocatorBase< void >	Disallow AllocatorBase for the type 'void' by generating a compiler error if it's used
CApacheLogEntry
CApacheLogParser
CApplicationHandler	Base clase for application handlers
►CApplicationQueue	Application queue
CApplicationQueueState	Application queue state shared among worker threads
CGroupState	Tracks group execution state
CRequestRec	Request record
CWorker	Application queue worker thread function (functor)
CApplicationQueueInterface	Abstract interface for application queue
CArenaAllocatorBase	Specialized Allocator class using a Memory Arena which manages the allocated memory; see PageArenaAllocator.h for an actual implementation
CBalanceAlgorithm
CBalanceAlgorithmEvenRanges
►CBalanceAlgorithmLoad
CGtRangeMetricSummary
CGtServerMetricSummary
CRangeMetricSummary
CServerMetricSummary
CBalanceAlgorithmOffload
CBalancePlan	Balance plan
►CBalancePlanAuthority	Central authority for balance plans
Clt_move_spec	StrictWeakOrdering class for set of RangeMoveSpecs
CRecoveryPlans	Holds plans for each range type
►CBarrier	A Barrier to block execution of code
CScopedActivator	A helper class to put up a barrier when entering a scope and take it down when leaving the scope
CBase64	Provides base64 encoding and decoding functions
CBasicBloomFilter	A space-efficent probabilistic set for membership test, false postives are possible, but false negatives are not
CBasicBloomFilterWithChecksum	A space-efficent probabilistic set for membership test, false postives are possible, but false negatives are not
CBlob	A Blob structure holds a data pointer and a size
CBlobHashSet	A HashSet for storing and looking up blobs efficiently
►CBlobHashTraits	Traits for BlobHashSet Hash function default to MurmurHash2 for speed and mix
Chasher
Ckey_equal
CBlockCompressionCodec	Abstract base class for block compression codecs
CBlockCompressionCodecBmz	Block compressor that uses the BMZ algorithm
CBlockCompressionCodecLzo	Block compressor that uses the LZO algorithm
CBlockCompressionCodecNone	Block compressor that performs no compression
CBlockCompressionCodecQuicklz	Block compressor that uses the QUICKLZ algorithm
CBlockCompressionCodecSnappy	Block compressor that uses the SNAPPY algorithm
CBlockCompressionCodecZlib	Block compressor that uses the ZLIB algorithm
CBlockHeader	Base class for block headers
CBlockHeaderCellStore	Cell store block header
CBlockHeaderCommitLog	Commit log block header
CByteString	A class managing one or more serializable ByteStrings
CCanonicalize	Static class with methods for canonicalizing table and namespace names
CCell	Encapsulates decomposed key and value
►CCellCache	Represents a sorted list of key/value pairs in memory
CStatistics	Holds cache statistics
►CCellCacheAllocator
Crebind
CCellCacheManager	Manages the cell cache of an access group
CCellCachePageAllocator
►CCellCacheScanner	Provides a scanning interface to a CellCache
CCellCacheEntry
CCellList	Abstract base class for cell lists (sorted lists of key/value pairs)
CCellListScanner
►CCellListScannerBuffer	Cell list scanner over a buffer of cells
CLtKeyValueT	STL Strict Weak Ordering for KeyValueT
►CCellPredicate	Cell predicate
CCellPattern
CCellsBuilder
►CCellStore	Abstract base class for persistent cell lists (ones that are stored on disk)
CIndexMemoryStats
CCellStoreBlockIndexArray
CCellStoreBlockIndexElementArray
CCellStoreBlockIndexIteratorArray	Provides an STL-style iterator on CellStoreBlockIndex objects
CCellStoreFactory	Factory class for creating CellStore objects
CCellStoreInfo
CCellStoreReleaseCallback
CCellStoreScanner	Provides the ability to scan over (query) a cell store
►CCellStoreScannerInterval
CBlockInfo
CCellStoreScannerIntervalBlockIndex	Provides the ability to scan over a portion of a cell store using its block index
CCellStoreScannerIntervalReadahead	Provides ability to efficiently scan over a portion of a cell store
CCellStoreTrailer	Abstract base class for cell store trailer
CCellStoreTrailerV0
CCellStoreTrailerV1
CCellStoreTrailerV2
CCellStoreTrailerV3
CCellStoreTrailerV4
CCellStoreTrailerV5
CCellStoreTrailerV6
CCellStoreTrailerV7	Represents the trailer for CellStore version 7
CCellStoreV0
►CCellStoreV1
CIndexBuilder
►CCellStoreV2
CIndexBuilder
►CCellStoreV3
CIndexBuilder
►CCellStoreV4
CIndexBuilder
►CCellStoreV5
CIndexBuilder
►CCellStoreV6
CIndexBuilder
►CCellStoreV7
CIndexBuilder
CClient
CClientObject	Base class for Hypertable client objects
CClusterCommandInterpreter	Executes interactive cluster tool commands
CClusterId	Provides access to the cluster ID
CColumn
CColumnFamilyOptions	Specification for column family options
CColumnFamilySpec	Column family specification
CColumnSpec
CColumnString
CComm	Entry point to AsyncComm service
CCommAddress	Address abstraction to hold either proxy name or IPv4:port address
CCommAddressHash	Hash function (functor) for CommAddress objets
CCommAddressMap	Parameterized hash map for mapping CommAddress to arbitrary type
CCommandInterpreter
CCommandShell
CCommandShellPolicy
CCommBuf	Message buffer for holding data to be transmitted over a network
CCommHeader	Header for messages transmitted via AsyncComm
►CCommitLog	Commit log for persisting range updates
CCumulativeFragmentData
CCommitLogBase
CCommitLogBlockInfo	Holds information about an individual block
CCommitLogBlockStream	Abstraction for reading a stream of blocks from a commit log file
CCommitLogFileInfo
CCommitLogReader	Provides sequential access to blocks in a commit log
CCompressorFactory
CConnectionHandler	Handles incoming Master requests
CConnectionHandlerFactory	Abstract class for creating default application dispatch handlers
CConnectionInitializer	Driver interface for connection initialization handshake in ConnectionManager
►CConnectionManager	Establishes and maintains a set of TCP connections
CConnectionState	Per-connection state
CLtConnectionState	StringWeakOrdering for connection retry heap
CSharedImpl	Connection manager state shared between Connection manager objects
CConsoleOutputSquelcher	Temporarily redirects stdout and stderr to /dev/null
►CContext	Execution context for the Master
CRecoveryState
CCpuInfo	A structure to retrieve CPU information (vendor, model, speed, number of cores etc.)
CCpuStat	A structure to retrieve CPU statistics (system wide cpu times, idle time etc)
CCronolog	Time based rotating log
CCrontab	Tracks timing of periodic events
Ccrontab_entry	Binary representation of crontab spec
CCrypto	Provides cryptographic functions
►CCstrCaseHashTraits
Chasher
Ckey_equal
CCstrHashMap	A hash map for storing and lookup char * strings efficiently
►CCstrHashTraits	Traits for CstrHashMap/Set
Chasher
Ckey_equal
CDataGenerator
CDataGeneratorIterator	Provides an STL-style iterator on DataGenerator objects
CDataGeneratorPolicy
CDataSource
CDefaultPageAllocator	A memory allocator using std::malloc() and std::free()
►Cdirectory	Directory container class
Cvalue_compare	Ordering relation on value_type
Cdirectory_entry
CDiscreteRandomGenerator	Generates samples from a discrete probability distribution in the range [0, max_val] by transforming a uniform [0, 1] distribution into the desired distribution
CDiscreteRandomGeneratorFactory	Static factory class for discrete random generators
CDiscreteRandomGeneratorUniform	Generate samples from Uniform distribution
CDiscreteRandomGeneratorZipf	Generate samples from Zipf distribution http://en.wikipedia.org/wiki/Zipf%27s_law
CDiskStat	A structure to retrieve disk statistics (read/write IOPS, transfer rates etc)
CDispatchHandler	Abstract base class for application dispatch handlers registered with AsyncComm
►CDispatchHandlerOperation	DispatchHandler class for managing async RangeServer requests
CLtEventPtr	Strict Weak Ordering for comparing events by source address
CResult	Holds request result information
CDispatchHandlerOperationAlterTable
CDispatchHandlerOperationCompact	Dispatch handler to aggregate a set of RangeServer::compact results
CDispatchHandlerOperationDropTable
CDispatchHandlerOperationGetStatistics
CDispatchHandlerOperationSetState	DispatchHandler class for gathering responses to a set of RangeServer::set_state() requests
►CDispatchHandlerOperationSystemStatus	Carries out scatter/gather requests for RangeServer status
CResult	Holds result of a RangeServer status request
CDispatchHandlerOperationToggleTableMaintenance	Dispatch handler for either enabling or disabling table maintenance by issuing requests to range servers and aggregating the responses
CDispatchHandlerSynchronizer	DispatchHandler class used to synchronize with response messages
CDynamicBuffer	A dynamic, resizable and reference counted memory buffer
CEndpoint	High-level entry point to a service; wraps a host:port pair
CEvent	Network communication event
CException	This is a generic exception class for Hypertable
CExceptionMessageRenderer	Helper class to render an exception message a la IO manipulators
CExceptionMessagesRenderer	Helper class to render an exception message a la IO manipulators
CExpireTimer	State record for timer
CFailedRegionAsync
►CFailureInducer
Cfailure_inducer_state	Internal structure to store a single failure setting
►CFileBlockCache
CBlockCacheEntry
CDecrementRefCount
CHashI64
►CFilesystem	Abstract base class for a filesystem
CDirent	Directory entry
CFileUtils	Static functions to easily access and handle files and the file system
CFixedIstream	Input stream using a fixed buffer
CFixedOstream	Output stream using a fixed buffer
CFixedRandomStringGenerator
CFixedStreamBuf	A simple streambuf with fixed size buffer
CFlyweightString	The Flyweight string set stores duplicate strings efficiently
CFragmentData	Accumulates phantom update data for a phantom range
CFsStat	A structure to retrieve Filesystem statistics (total size, free size, used size etc)
CFuture
CGcWorker
CGlobal
CGroupCommit	Group commit manager
CGroupCommitInterface	Abstract base class for group commit implementation
CGroupCommitTimerHandler
CHandlerFactory
CHandlerMap	Data structure for mapping socket addresses to I/O handlers
CHostSpecification	Converts host specification pattern to list of host names
CHqlCommandInterpreter	HQL command interpreter
CHqlHelpText	Holds and provides access to help text
►CHqlInterpreter	The API of HQL interpreter
CCallback	Callback interface/base class for execute
CSmallCallback	An example for simple queries that returns small number of results
CHyperspaceSessionHandler
►CHyperspaceTableCache	Provides efficient lookup of Hyperspace table data
CEntry	Cache entry for Hyperspace table data
CIndexMutatorCallback	ResultCallback for secondary indices; used by TableMutatorAsync
CIndexScannerCallback	ResultCallback for secondary indices; used by TableScannerAsync
CIndexUpdater	Helper class for updating index tables
CIndexUpdaterCallback
CIndexUpdaterFactory	Factory class for creating IndexUpdater objects
CInetAddr	Encapsulate an internet address
CInteractiveCommand	Abstract base class for simple interactive shell commands
CIntervalScannerAsync
CIOHandler	Base class for socket descriptor I/O handlers
CIOHandlerAccept	I/O handler for accept (listen) sockets
CIOHandlerData	I/O handler for TCP sockets
CIOHandlerDatagram	I/O handler for datagram (UDP) sockets
CIOHandlerRaw	I/O handler for raw sockets
CKey	Provides access to internal components of opaque key
Ckey_revision_lt
CKeyCompressor
CKeyCompressorNone
CKeyCompressorPrefix
CKeyDecompressor
CKeyDecompressorNone
CKeyDecompressorPrefix
CKeySpec
CKeySpecBuilder	Helper class for building a KeySpec
CLiveFileTracker	Tracks files that are live or referenced for purposes of maintaining the 'Files' METADATA column
CLoadAvgStat	A structure to retrieve load average-statistics
CLoadBalancer
CLoadDataEscape
►CLoadDataSource
CColumnInfo
CKeyComponentInfo
CLoadDataSourceFactory
CLoadDataSourceFileDfs
CLoadDataSourceFileLocal
CLoadDataSourceStdin
CLoadFactors
CLoadMetricsRange
CLoadRec
►CLoadStatistics	Computes application load statistics
CBundle	POD-style structure to hold statistics
CLoadThread
►CLocationCache	This class acts as a cache of Range location information
CCommAddressPointerLt	STL Strict Weak Ordering for comparing CommAddress pointers
CValue
CLocationCacheKey	Key type for Range location cache
CLocationInitializer	Obtains location string (proxy name) for the range server
CLogReplayBarrier	Blocks requests until specific commit log has finished replaying
Clt_ctip	Comparison functor for ClusterTableIdPair objects
CLtCellStoreBlockIndexElementArray
CLtClfip
CLtNamespaceListingId
CLtNamespaceListingName
CLtQualifiedRangeSpecManaged
CltStringPtr
CLtTimerHeap	Comparison function (functor) for timer heap
►CMaintenancePrioritizer
CMemoryState
CMaintenancePrioritizerLogCleanup
CMaintenancePrioritizerLowMemory
►CMaintenanceQueue	Queue for periodic maintenance work
CLtMaintenanceTask
CMaintenanceQueueState
CWorker
CMaintenanceScheduler	Schedules range server maintenance
CMaintenanceTask
CMaintenanceTaskCompaction
CMaintenanceTaskDeferredInitialization
CMaintenanceTaskMemoryPurge
CMaintenanceTaskRelinquish
CMaintenanceTaskSplit
CMaintenanceTaskWorkQueue
CMemoryTracker	Tracks range server memory used
CMemStat	A structure to retrieve memory statistics (RAM size, used size, free size etc)
►CMergeScannerAccessGroup	Merge scanner for access groups
CLtScannerState
CRegexpInfo
CScannerState
►CMergeScannerRange	Performs a scan over a range
CLtScannerState
CScannerState
CMetadata
►CMetadataNormal
CAgMetadata
CMetadataRoot
CMetaLogEntityRange	MetaLog entity for range state persisted in RSML
CMetaLogEntityRemoveOkLogs	MetaLog entity to track transfer logs that can be safely removed
CMetrics	Metrics interface
CMetricsCollector	Abstract metrics collector
CMetricsCollectorGanglia	Ganglia metrics collector
CMetricsHandler	Collects and publishes Master metrics
CMetricsProcess	Computes and publishes general process metrics
►CMonitoring
Crangeserver_rrd_data
Ctable_rrd_data
CMurmurHash2	Helper structure using overloaded operator() to calculate hashes of various input types
CMutexWithStatistics	Mutex that maintains wait threads count
CNameIdMapper	Easy mapping between a Table/Namespace name string to ids and vice versa
CNamespace
CNamespaceCache
CNamespaceListing
CNetInfo	A structure to retrieve network information (host name, primary interface, primary address, gateway etc)
CNetStat	A structure to retrieve network statistics (receiving rate, transmitting rate etc)
CNotificationMessage	Holds a notification message to be deliverd to the administrator
CNotifier
CNumericFormatter
CNumericFormatterDigits	The fast numeric formatters, very much inspired from http://cppformat.github.io/
CNumericSignedFormatter
CNumericUnsignedFormatter
CObjScopeGuardImpl0	ScopeGuard implementation for method with no parameter
CObjScopeGuardImpl1	ScopeGuard implementation for method with 1 parameter
CObjScopeGuardImpl2	ScopeGuard implementation for method with 2 parameters
COperation	Abstract base class for master operations
COperationAlterTable	Carries out an alter table operation
COperationBalance
COperationCollectGarbage
COperationCompact	Carries out a manual compaction operation
COperationCreateNamespace
COperationCreateTable	Carries out a create table operation
COperationDropNamespace
COperationDropTable	Carries out a drop table operation
COperationEphemeral	Abstract base class for ephemeral operations
COperationGatherStatistics	Gathers and processes RangeServer statistics
COperationInitialize
COperationMoveRange
►COperationProcessor	Runs a set of operaions with dependency relationships
Cbusy_t
Cexecution_time_t
Clabel_t
Cltvertexinfo
Cnot_permanent
Coperation_t
COperationVertex
Cpermanent_t
CThreadContext
Cvertex_info
CWorker
COperationRecover	Carries out recovery operaton for a range server
COperationRecoverRanges
COperationRecoveryBlocker
COperationRecreateIndexTables	Reconstructs a table's index tables
COperationRegisterServer
COperationRegisterServerBlocker	Blocks range server registration
COperationRelinquishAcknowledge
COperationRenameTable
COperationSetState	Carries out a set variables operation
COperationStatus
COperationStop
COperationSystemStatus
COperationSystemUpgrade
COperationTimedBarrier
COperationToggleTableMaintenance	Enables or disables maintenance for a table
COperationWaitForServers
COsInfo	A structure to retrieve operating system information (name, version, vendor, architecture)
►CPageArena	The PageArena allocator is simple and fast, avoiding individual mallocs/frees
CLtPageRemain	Predicate which sorts by size
CPage	A structure to manage a single memory page which is used to allocate smaller memory chunks
CTinyBuffer	A small buffer (128 bytes) to satisfy very small memory allocations without allocating a page from the heap
►CPageArenaAllocator	The PageArenaAllocator is a STL allocator based on PageArena
Crebind
CParallelStateRec
CPath	Compatibility class for boost::filesystem::path
CPhantomRange	Represents a "phantom" range
CPhantomRangeMap	Provides a mapping from table name to TableInfo object
CPollDescriptorT	Socket descriptor poll state for use with POSIX poll()
CPollTimeout	Maintains next timeout for event polling loop
CProcInfo	A structure to receive process information (pid, user name, exe name, working directory, program arguments etc)
CProcStat	A structure to receive process statistics (CPU user time, system time, virtmal machine sizes etc)
CProfileDataScanner	Scanner profile data
CProperties	Manages a collection of program options
CProtocol	Abstract base class for server protocol drivers
CProxyAddressInfo	Holds address and hostname associated with a proxy name
CProxyMap	Maps a set of proxy names to their associated IP addresses
CPseudoTables	Singleton class holding Schema objects for pseudo tables
CQualifiedRangeEqual
CQualifiedRangeHash
CQualifiedRangeSpec	Qualified (with table identifier) range specification
CQualifiedRangeSpecManaged	Qualified (with table identifier) range specification, with storage
CQualifier
CQualifierFactory
CQualifierSpec
CQualifierString
►CQueryCache	Query cache
CKey	Hash key to query cache
CKeyHash
CQueryCacheEntry	Internal cache entry
CRowKey	Row key information
CRowKeyHash
CQueryThread
CRandom	Convenience interface for random number and data generation
►CRange	Represents a table row range
CMaintenanceData
CRangeAddrInfo	Holds range location
CRangeData	Holds pointers to a Range and associated Range::MaintenanceData
CRangeInfo	Holds pointer to range and cached start and end rows
CRangeLocationInfo	Holds range start and end row plus location
CRangeLocator	Locates containing range given a key
CRangeLocatorHyperspaceSessionCallback
►CRangeMaintenanceGuard
CActivator
CRangeMoveSpec	Range move specification
CRangeReplayBuffer
CRanges	Holds vector of RangeData objects and memory arena
CRangeServerConnection
►CRangeServerConnectionManager
CInetAddrHash
CRangeServerConnectionEntry
CRangeServerHyperspaceCallback	Callback class for range server lock files
CRangeServerState
CRangeServerStatistics
CRangeSet	Interface for removing a range or changing its end row in a Range set
CRangeSpec	Range specification
CRangeSpecManaged	Wrapper for RangeSpec providing member storage
CRangeState	Range state
CRangeStateManaged	Range state with memory management
CRangeTransferInfo
CRawSocketHandler	Abstract base class for application raw socket handlers registered with AsyncComm
CReactor	Manages reactor (polling thread) state including poll interest, request cache, and timers
CReactorFactory	Static class used to setup and manage I/O reactors
CReactorRunner	Thread functor class for reacting to I/O events
CRecoveredServers	Set of recovered servers
CRecoveryStepFuture	Tracks outstanding RangeServer recover requests
CReferenceManager	Holds references to operations that are to be manually removed
CRefHolder	Helper class used to pass a parameter to the ScopeGuard by reference
CRegex	Provides utility functions for regular expressions
CReplayBuffer
CReplayDispatchHandler
►CRequestCache	Class used to hold pending request callback handlers
CCacheNode	Internal cache node structure
CResponseCallback	This class is used to generate and deliver standard responses back to a client
CResponseManager	Manages the sending of operation results back to clients
►CResponseManagerContext	Implementation shared by ResponseManager objects
CDeliveryRec	Record holding response delivery information for an operation
COperationRec	Record holding completed operation information
CResult
CResultCallback	Represents an open table
CRootFileHandler
CRowComponent
CRowComponentInteger
CRowComponentSpec
CRowComponentString
CRowComponentTimestamp
CScanBlock	Encapsulates a block of scan results
CScanContext	Scan context information
►CScannerMap	Map to hold outstanding scanners
CScanInfo	Holds scanner information
CSchema	Schema specification
CScopeGuardImpl0	ScopeGuard implementation for free function with no paramter
CScopeGuardImpl1	ScopeGuard implementation for free function with 1 parameter
CScopeGuardImpl2	ScopeGuard implementation for free function with 2 parameters
CScopeGuardImpl3	ScopeGuard implementation for free function with 3 parameters
CScopeGuardImplBase	Base class for the ScopeGuards
CSendBackRec	Describes portion of an update buffer rejected due to error
CSerializable	Mixin class that provides a standard serialization interface
CSerializedCellsReader
CSerializedCellsWriter
CSerializedKey
CServerLauncher	Launches external commands and redirects their output to a file; kills the external process when going out of scope
CServerState	Holds dynamic server state
CSleepWakeNotifier	Delivers sleep and wakeup notifications
CSockAddrEqual	Equality predicate functor class for InetAddr
CSockAddrHash	Hash functor class for InetAddr
CSockAddrMap	Unordered map specialization for InetAddr keys
►CSshOutputCollector	Collects buffers of output from execution of remote SSH command
CBuffer	Fixed-size buffer to hold a portion of output
Citerator	Iterator for traversing output line-by-line
CSshSocketHandler	Raw socket handler for ssh protocol driver
CSshThreadsCallbacks	Thread callbacks for libssh
CStaticBuffer	A memory buffer of static size
CStatsRangeServer
CStatsSerializable	Abstract base class for managing serialized statistics
CStatsSystem	Collects, serializes and deserializes system-wide statistics
CStatsTable
►CStatus	Holds Nagios-style program status information
CText	Status text string constants
CStatusPersister	Persists program status information to disk
►CStlAllocator	Stl compatible memory allocator based on a PageArena
Crebind
CStopwatch	Measures elapsed time between instantiation (or a call to start) and a call to stop
CStringCompressorPrefix	A class to prefix-compress strings
CStringDecompressorPrefix	A class to decompress prefix-compressed strings
CSubProperties	Helper class to access parts of the properties
CSwapStat	A structure to retrieve Swapping statistics (pages swapped in/out, aggregate total numbers etc)
CSystem
CSystemState	Holds persistent global system state
CTable	Represents an open table
CTableCache
CTableCallback	Represents an open table
CTableDumper
CTableIdentifier	Table identifier
CTableIdentifierManaged	Wrapper for TableIdentifier providing member storage
CTableInfo	Holds set of range objects for a table
CTableInfoMap	Manages live range map and set of log names that can be safely removed
CTableMutator	Provides the ability to mutate a table in the form of adding and deleting rows and cells
CTableMutatorAsync	Provides the ability to mutate a table in the form of adding and deleting rows and cells
CTableMutatorAsyncCompletionCounter	Tracks outstanding RangeServer update requests
CTableMutatorAsyncDispatchHandler	This class is a DispatchHandler
CTableMutatorAsyncHandler	This class is a DispatchHandler
CTableMutatorAsyncScatterBuffer
CTableMutatorAsyncSendBuffer
CTableMutatorCompletionCounter	Tracks outstanding RangeServer update requests
CTableMutatorFlushHandler
CTableMutatorIntervalHandler	Timer handler for periodically flushing a shared mutator
CTableMutatorQueue	Provides application work queue and worker threads
CTableMutatorShared	A TableMutator that can be shared from multiple threads and incidentally has an option to do periodic flushes
►CTableMutatorSyncDispatchHandler	This class is a DispatchHandler class that is used for collecting asynchronous commit log sync requests
CErrorResult
CTableParts	Represents a set of table parts (sub-tables)
CTableScanner	Synchronous table scanner
CTableScannerAsync	Asynchronous table scanner
CTableScannerDispatchHandler
CTableScannerHandler
CTableScannerQueue	Provides application work queue and worker threads
CTableSplit	Represents a table split
CTableSplitBuilder
CTableSplitsContainer
CTclHash	Helper structure using overloaded operator() to calculate the Tcl hashes of various input types
CTclHash2	Helper structure using overloaded operator() to calculate the Tcl hashes of various input types (using tcl_hash2, the faster implementation)
CTermInfo	A structure to retrieve terminal information (lines, columns etc)
CTestData
CTestFun	Helper class wrapping the invocation of a single test function
CTestHarness	A simple test framework which sets up the logging subsystem, can compare its output against a golden file or regenerate the golden file
CTestSource
CTestStat	Accumulates min, max, mean and stdev of the test results; based on the Welford method for numerical stability (see http://www.johndcook.com/standard_deviation.html)
CTimer	A timer class to keep timeout states across AsyncComm related calls
CTimerHandler	Timer interrupt handler
CTimeWindow	Defines a time window
CTransferLog	Creates a unique range transfer log pathname
CUpdateContext	Context record for update request passed into UpdatePipeline
CUpdatePipeline	Three-staged, multithreaded update pipeline
CUpdateRecRange	Specifies a range of updates (key/value pairs) within a buffer
CUpdateRecRangeList	Holds updates destined for a specific range
CUpdateRecTable	Holds updates destined for a specific table
CUpdateRequest	Holds client update request and error state
CUsage	Helper class for printing usage banners on the command line
►CWordStream	A class generating a stream of words; the words are retrieved from a file and can be randomized
Cword_info	Internal structure for a single word
CXmlParser	Base class for XML document parsers
►Nstd	STL namespace
►Nchrono
Cfast_clock
►NTools	Forward declarations
►Nclient
►Nfsbroker
►CCommandInterpreter	Command interpreter for ht_fsbroker
CParseResult
CFsTestThreadFunction	Thread function class for fsbroker test
►Nmaster
CMasterCommandInterpreter
►Nrangeserver
CRangeServerCommandInterpreter
CTableInfo
►Nthriftbroker
►CCommandInterpreter	Command interpreter for ht_thriftbroker
CParseResult
CAboutController	Copyright (C) 2007-2015 Hypertable, Inc
CAppPolicy
CBmLut
CBmLutEntry
CBootstrap
CColumnInfo
CErrorController	Copyright (C) 2007-2015 Hypertable, Inc
Cfmem
Cfreebase_parser
CHandlerFactory	This handler factory gets passed into Comm::listen
CHypertableConnection	Copyright (C) 2007-2015 Hypertable, Inc
CIndexController	Copyright (C) 2007-2015 Hypertable, Inc
CInsertRec
CLoadClient
CLocationThread
CLoginController	Copyright (C) 2007-2015 Hypertable, Inc
CLoginForm	Copyright (C) 2007-2015 Hypertable, Inc
CLtCstr	STL Strict Weak Ordering for comparing c-style strings
Cmd5_context	MD5 context structure; this structure is used to store the internal state of the md5 algorithm
CMyAuthAdapter	Copyright (C) 2007-2015 Hypertable, Inc
CProfile	Copyright (C) 2007-2015 Hypertable, Inc
CProfileController	Copyright (C) 2007-2015 Hypertable, Inc
CProfileForm	Copyright (C) 2007-2015 Hypertable, Inc
CProfileTable	Copyright (C) 2007-2015 Hypertable, Inc
CRangeInfo
CResponseHandler	(somewhat) Abstract base class for response handlers; Defines the message queue and the mutex and condition variable to protect it
CResponseHandlerTCP	This is the dispatch handler that gets installed as the default handler for the TCP connection
CResponseHandlerUDP	This is the dispatch handler that gets installed as the default handler for UDP mode
CSendForm	Copyright (C) 2007-2015 Hypertable, Inc
CSessionHandler
CSignupForm	Copyright (C) 2007-2015 Hypertable, Inc
CSshThreadsCallbacks
CTweet	Copyright (C) 2007-2015 Hypertable, Inc
CTweetTable	Copyright (C) 2007-2015 Hypertable, Inc
CUser	Copyright (C) 2007-2015 Hypertable, Inc
CUserTable	Copyright (C) 2007-2015 Hypertable, Inc
CZF