Namespaces
namespace	Config
namespace	Dependency
namespace	DfsBroker
namespace	Error
namespace	Hql
namespace	KeyCompressionType
namespace	LoadDataFlags
namespace	Logger
namespace	MaintenanceFlag
namespace	Meta
namespace	MetaLog
namespace	NamespaceFlag
namespace	OldMetaLog
namespace	OperationState
namespace	Property
namespace	RangeServerConnectionState
namespace	Serialization
namespace	SerializedCellsFlag
namespace	ThisThread
namespace	Thrift
namespace	ThriftBroker
namespace	ThriftGen
namespace	Utility
Classes
class	ApplicationHandler
	Abstract base clase for application request handlers. More...
class	ApplicationQueue
	Provides application work queue and worker threads. More...
class	Comm
	Provides communication (message passing) services to an application. More...
class	CommAddress
class	CommAddressHash
struct	CommAddressEqual
class	CommAddressMap
class	CommBuf
	Message buffer sent over the network by the AsyncComm subsystem. More...
class	CommHeader
class	ConnectionHandlerFactory
class	ConnectionInitializer
class	ConnectionManager
	Establishes and maintains a set of TCP connections. More...
class	DispatchHandler
	Abstract base class that is the main callback class of the Comm layer. More...
class	DispatchHandlerSynchronizer
	This class is a DispatchHandler class that can be used by a client to synchronize with response messages resulting from previously sent request messages. More...
class	Event
	Objects of the is class represent communication events. More...
struct	ExpireTimer
struct	LtTimer
class	HandlerMap
class	IOHandler
struct	ltiohp
class	IOHandlerAccept
class	IOHandlerData
class	IOHandlerDatagram
class	PollTimeout
class	Protocol
class	ProxyMap
struct	PollDescriptorT
class	Reactor
class	ReactorFactory
	This class is a static class that is used to setup and manage I/O reactors. More...
class	ReactorRunner
class	RequestCache
class	ResponseCallback
	This class is used to deliver responses, corresponding to a request, back to a client. More...
struct	AllocatorBase< void >
struct	AllocatorBase
class	ArenaAllocatorBase
class	Barrier
class	BlobHashSet
	A hash set for storing and lookup blob efficiently. More...
struct	Blob
struct	BlobHashTraits
	Traits for BlobHashMap/Set Hash function default to MurmurHash2 for speed and mix. More...
class	BasicBloomFilter
	A space-efficent probabilistic set for membership test, false postives are possible, but false negatives are not. More...
class	BasicBloomFilterWithChecksum
	A space-efficent probabilistic set for membership test, false postives are possible, but false negatives are not. More...
class	ByteString
class	CstrHashMap
	A hash map for storing and lookup char *strings efficiently. More...
struct	CstrHashTraits
	Traits for CstrHashMap/Set. More...
struct	CstrCaseHashTraits
class	DiscreteRandomGenerator
	Generates samples from a discrete probability distribution in the range [0, max_val] by transforming a uniform [0,1] distribution into the desired distribution. More...
class	DiscreteRandomGeneratorFactory
class	DiscreteRandomGeneratorUniform
	Generate samples from Uniform distribution. More...
class	DiscreteRandomGeneratorZipf
	Generate samples from Zipf distribution http://en.wikipedia.org/wiki/Zipf%27s_law. More...
class	DynamicBuffer
struct	ExceptionMessageRenderer
struct	ExceptionMessagesRenderer
class	Exception
	This is a generic exception class for Hypertable. More...
class	FailureInducer
class	Filesystem
	Abstract base class for a filesystem. More...
class	FileUtils
class	FixedStreamBuf
	A simple streambuf with fixed size buffer Convenient for limitting size of output; faster than ostringstream and friends, which require heap allocations. More...
class	FixedOstream
	Output stream using a fixed buffer. More...
class	FixedIstream
	Input stream using a fixed buffer. More...
class	FlyweightString
struct	Endpoint
	High-level entry point to a service. More...
struct	InetAddr
	Encapsulate an internet address. More...
class	InteractiveCommand
struct	Lookup3
class	Math
struct	MurmurHash2
class	Locker
	boost::mutex::scoped_lock use lock_ops<mutex>::lock/unlock in pre 1.35 which makes it less convenient than the following which can be used to guard any object (besides a typical mutex) with lock/unlock methods More...
class	Mutex
class	RecMutex
class	NumberStream
struct	DefaultPageAllocator
class	PageArena
	A simple/fast allocator to avoid individual deletes/frees Good for usage patterns that just: load, use and free the entire container repeatedly. More...
struct	PageArenaAllocator
struct	PageArenaDownAllocator
class	Path
	Yet another compatibility class, since boost 1.36+ replaced branch_path and leaf with parent_path and filename. More...
class	Properties
class	SubProperties
	Convenient help class for access parts of properties. More...
class	Random
class	ReferenceCount
	This class is meant to be a base class for all classes that want to be referenced by Boost intrusive pointers. More...
class	Runnable
class	ScopeGuardImplBase
class	ScopeGuardImpl0
	Guard implementation for free function with no paramter. More...
class	ScopeGuardImpl1
	Guard implementation for free function with 1 parameter. More...
class	ScopeGuardImpl2
	Guard implementation for free function with 2 parameters. More...
class	ScopeGuardImpl3
	Guard implementation for free function with 3 parameters. More...
class	ObjScopeGuardImpl0
	Guard implementation for method with no parameter. More...
class	ObjScopeGuardImpl1
	Guard implementation for method with 1 parameter. More...
class	ObjScopeGuardImpl2
	Guard implementation for method with 2 parameters. More...
class	RefHolder
	Used to pass parameter to the scope guard by reference e.g. More...
class	ServerLauncher
class	SockAddrHash
struct	SockAddrEqual
class	SockAddrMap
class	StaticBuffer
struct	LtStaticBuffer
class	StatsSerializable
class	StatsSystem
struct	SgiHash
struct	Tr1Hash
class	Stopwatch
class	StringCompressorPrefix
class	StringDecompressorPrefix
struct	SuperFastHash
class	System
struct	CpuInfo
struct	CpuStat
struct	LoadAvgStat
	Reports loadavg normalized over cores. More...
struct	MemStat
struct	DiskStat
struct	SwapStat
struct	NetInfo
struct	NetStat
struct	OsInfo
struct	ProcInfo
struct	ProcStat
struct	FsStat
struct	TermInfo
struct	TclHash
struct	TclHash2
class	TestHarness
class	TestStat
struct	TestFun
struct	HiResTime
	High-Resolution Time. More...
class	Timer
	A timer class to keep timeout states across comm related calls. More...
class	Usage
class	OpenFileDataCeph
class	OpenFileDataCephPtr
class	CephBroker
class	OpenFileDataKosmos
class	OpenFileDataKosmosPtr
class	KosmosBroker
class	ClientBufferedReaderHandler
class	OpenFileData
class	OpenFileMap
class	OpenFileDataLocal
class	OpenFileDataLocalPtr
class	LocalBroker
class	ApacheLogEntry
class	ApacheLogParser
class	BlockCompressionCodec
	Abstract base class for block compression codecs. More...
class	BlockCompressionCodecBmz
class	BlockCompressionCodecLzo
class	BlockCompressionCodecNone
class	BlockCompressionCodecQuicklz
class	BlockCompressionCodecZlib
class	BlockCompressionHeader
	Base class for compressed block header. More...
class	BlockCompressionHeaderCommitLog
	Base class for compressed block header for Cell Store blocks. More...
class	Cell
	Encapsulates decomposed key and value. More...
class	CellsBuilder
class	Client
struct	CumulativeFragmentData
class	CommitLog
	Commit log for persisting range updates. More...
struct	CommitLogFileInfo
class	CommitLogBase
class	CommitLogBlockInfo
class	CommitLogBlockStream
class	CommitLogReader
class	CompressorFactory
struct	DataGeneratorPolicy
class	DataGeneratorIterator
	Provides an STL-style iterator on DataGenerator objects. More...
class	DataGenerator
class	ColumnSpec
class	Column
class	ColumnString
class	QualifierSpec
class	Qualifier
class	QualifierString
class	QualifierFactory
class	RowComponentSpec
class	RowComponent
class	RowComponentInteger
class	RowComponentTimestamp
class	DataSource
class	EventHandlerMasterChange
class	FixedRandomStringGenerator
class	Future
class	HqlCommandInterpreter
class	HqlHelpText
class	HqlInterpreter
	The API of HQL interpreter. More...
class	IntervalScanner
class	IntervalScannerAsync
class	Key
	Provides access to internal components of opaque key. More...
class	KeySpec
class	KeySpecBuilder
	Helper class for building a KeySpec. More...
class	LoadDataEscape
class	LoadDataSource
class	LoadDataSourceFactory
class	LoadDataSourceFileDfs
class	LoadDataSourceFileLocal
class	LoadDataSourceStdin
struct	LocationCacheKey
	Key type for Range location cache. More...
class	LocationCache
	This class acts as a cache of Range location information. More...
class	MasterClientHyperspaceSessionCallback
class	MasterClient
class	MasterFileHandler
class	MasterProtocol
class	NameIdMapper
	Easy mapping between a Table/Namespace name string to ids and vice versa. More...
class	Namespace
class	NamespaceCache
class	NamespaceListing
struct	LtNamespaceListingName
struct	LtNamespaceListingId
class	RangeLocationInfo
	Holds range start and end row plus location. More...
class	RangeLocatorHyperspaceSessionCallback
class	RangeLocator
	Locates containing range given a key. More...
class	RangeServerClient
	Client proxy interface to RangeServer. More...
class	RangeServerProtocol
	Generates RangeServer protocol request messages. More...
class	RangeState
	Holds the persistent state of a Range. More...
class	RangeStateManaged
	Holds the storage the persistent state of a Range. More...
class	Result
class	ResultCallback
	Represents an open table. More...
class	RootFileHandler
class	ScanBlock
	Encapsulates a block of scan results. More...
class	ScanCells
	This class takes allows vector access to a set of cells contained in an EventPtr without any copying. More...
class	RowInterval
	Represents a row interval. More...
class	CellInterval
	Represents a cell interval. More...
class	ScanSpec
	Represents a scan predicate. More...
class	ScanSpecBuilder
	Helper class for building a ScanSpec. More...
class	Schema
class	SerializedKey
class	StatsRangeServer
class	StatsTable
class	Table
	Represents an open table. More...
class	TableCache
class	TableDumper
class	TableMutator
	Provides the ability to mutate a table in the form of adding and deleting rows and cells. More...
class	TableMutatorCompletionCounter
	Tracks outstanding RangeServer update requests. More...
class	TableMutatorDispatchHandler
	This class is a DispatchHandler class that can be used. More...
struct	TableMutatorFlushHandler
struct	TableMutatorIntervalHandler
class	TableMutatorScatterBuffer
struct	FailedRegion
class	TableMutatorSendBuffer
class	TableMutatorShared
	A TableMutator that can be shared from multiple threads and incidentally has an option to do periodic flushes. More...
class	TableMutatorSyncDispatchHandler
	This class is a DispatchHandler class that is used for collecting asynchronous commit log sync requests. More...
class	TableScanner
class	TableScannerAsync
class	TableScannerCallback
	Represents an open table. More...
class	TableScannerDispatchHandler
struct	TableScannerHandler
class	TableScannerQueue
	Provides application work queue and worker threads. More...
struct	TableSplit
	Represents a table split. More...
class	TableSplitBuilder
class	TableSplitsContainer
class	TestData
class	TestSource
class	Timestamp
class	TableIdentifier
	Identifies a specific table and generation. More...
class	TableIdentifierManaged
	Wrapper for TableIdentifier. More...
class	RangeSpec
	Identifies a range. More...
class	RangeSpecManaged
	RangeSpec with storage. More...
class	QualifiedRangeSpec
	RangeSpec with table id. More...
class	QualifiedRangeHash
struct	QualifiedRangeEqual
class	ConnectionHandler
class	Context
class	DispatchHandlerOperation
	This class is a DispatchHandler class that is used for managing asynchronous operations. More...
class	DispatchHandlerOperationAlterTable
class	DispatchHandlerOperationDropTable
class	DispatchHandlerOperationGetStatistics
class	GcWorker
class	Monitoring
class	Operation
class	OperationAlterTable
class	OperationCollectGarbage
class	OperationCreateNamespace
class	OperationCreateTable
class	OperationDropNamespace
class	OperationDropTable
class	OperationGatherStatistics
class	OperationGetSchema
class	OperationInitialize
class	OperationMoveRange
class	OperationProcessor
class	OperationRecoverServer
class	OperationRegisterServer
class	OperationRelinquishAcknowledge
class	OperationRenameTable
class	OperationStatus
class	OperationSystemUpgrade
class	OperationWaitForServers
class	RangeServerConnection
class	RangeServerState
class	RangeServerStatistics
class	ResponseManagerContext
class	ResponseManager
class	AccessGroup
class	AccessGroupGarbageTracker
struct	key_revision_lt
class	CellCache
	Represents a sorted list of key/value pairs in memory. More...
struct	CellCachePageAllocator
struct	CellCacheAllocator
class	CellCacheScanner
	Provides a scanning interface to a CellCache. More...
class	CellList
	Abstract base class for cell lists (sorted lists of key/value pairs). More...
class	CellListScanner
class	CellStore
	Abstract base class for persistent cell lists (ones that are stored on disk). More...
class	CellStoreBlockIndexIteratorMap
	Provides an STL-style iterator on CellStoreBlockIndex objects. More...
class	CellStoreBlockIndexMap
class	CellStoreFactory
class	CellStoreReleaseCallback
class	CellStoreScanner
class	CellStoreScannerInterval
class	CellStoreScannerIntervalBlockIndex
class	CellStoreScannerIntervalReadahead
class	CellStoreTrailer
	Abstract base class for cell store trailer. More...
class	CellStoreTrailerV0
class	CellStoreTrailerV1
class	CellStoreTrailerV2
class	CellStoreTrailerV3
class	CellStoreTrailerV4
class	CellStoreTrailerV5
class	CellStoreV0
class	CellStoreV1
class	CellStoreV2
class	CellStoreV3
class	CellStoreV4
class	CellStoreV5
class	FileBlockCache
class	Global
class	GroupCommit
struct	SendBackRec
class	UpdateRequest
class	RangeUpdate
class	RangeUpdateList
class	TableUpdate
class	GroupCommitInterface
struct	eqtid
class	GroupCommitTimerHandler
class	HandlerFactory
class	HyperspaceSessionHandler
class	KeyCompressor
class	KeyCompressorNone
class	KeyCompressorPrefix
class	KeyDecompressor
class	KeyDecompressorNone
class	KeyDecompressorPrefix
class	LiveFileTracker
	Tracks files that are live or referenced for purposes of maintaining the 'Files' METADATA column. More...
class	LoadMetricsRange
class	LocationInitializer
class	MaintenancePrioritizer
class	MaintenancePrioritizerLogCleanup
class	MaintenancePrioritizerLowMemory
class	MaintenanceQueue
class	MaintenanceScheduler
class	MaintenanceTask
class	MaintenanceTaskCompaction
class	MaintenanceTaskMemoryPurge
class	MaintenanceTaskRelinquish
class	MaintenanceTaskSplit
class	MemoryTracker
class	MergeScanner
class	Metadata
class	MetadataNormal
class	MetadataRoot
class	QueryCache
class	Range
	Represents a table row range. More...
class	RangeMaintenanceGuard
class	RangeServer
class	RangeSet
	Interface for removing a range or changing its end row in a Range set. More...
class	RangeStatsGatherer
class	RangeTransferInfo
class	RequestHandlerAcknowledgeLoad
class	RequestHandlerClose
class	RequestHandlerCommitLogSync
class	RequestHandlerCompact
class	RequestHandlerCreateScanner
class	RequestHandlerDestroyScanner
class	RequestHandlerDoMaintenance
class	RequestHandlerDropRange
class	RequestHandlerDropTable
class	RequestHandlerDump
class	RequestHandlerFetchScanblock
class	RequestHandlerGetStatistics
class	RequestHandlerGroupCommit
class	RequestHandlerLoadRange
class	RequestHandlerRelinquishRange
class	RequestHandlerReplayBegin
class	RequestHandlerReplayCommit
class	RequestHandlerReplayLoadRange
class	RequestHandlerReplayUpdate
class	RequestHandlerStatus
class	RequestHandlerUpdate
class	RequestHandlerUpdateSchema
class	RequestHandlerWaitForMaintenance
class	ResponseCallbackCreateScanner
class	ResponseCallbackFetchScanblock
class	ResponseCallbackGetStatistics
class	ResponseCallbackUpdate
class	RSStats
class	CellFilterInfo
class	ScanContext
	Scan context information. More...
class	ScannerMap
class	TableIdCache
class	TableInfo
class	TableInfoMap
	Provides a mapping from table name to TableInfo object. More...
class	TimerHandler
class	TimerInterface
class	SerializedCellsReader
class	SerializedCellsWriter
class	CommandCopyFromLocal
class	CommandCopyToLocal
class	CommandExists
class	CommandLength
class	CommandMkdirs
class	CommandRemove
class	CommandRmdir
class	CommandShutdown
class	DfsTestThreadFunction
class	CommandInterpreter
class	CommandShell
class	Notifier
	Helper class which sends notification to specified address. More...
class	LoadThread
class	LoadRec
class	ParallelStateRec
class	MasterCommandInterpreter
class	RangeServerCommandInterpreter
Typedefs
typedef boost::intrusive_ptr < ApplicationQueue >	ApplicationQueuePtr
typedef std::set< CommAddress >	CommAddressSet
typedef intrusive_ptr< CommBuf >	CommBufPtr
typedef intrusive_ptr < ConnectionHandlerFactory >	ConnectionHandlerFactoryPtr
typedef boost::intrusive_ptr < ConnectionInitializer >	ConnectionInitializerPtr
typedef boost::intrusive_ptr < ConnectionManager >	ConnectionManagerPtr
typedef intrusive_ptr < DispatchHandler >	DispatchHandlerPtr
typedef boost::intrusive_ptr < Event >	EventPtr
typedef boost::intrusive_ptr < HandlerMap >	HandlerMapPtr
typedef boost::intrusive_ptr < IOHandler >	IOHandlerPtr
typedef intrusive_ptr < IOHandlerAccept >	IOHandlerAcceptPtr
typedef intrusive_ptr < IOHandlerData >	IOHandlerDataPtr
typedef boost::intrusive_ptr < IOHandlerDatagram >	IOHandlerDatagramPtr
typedef hash_map< String, InetAddr >	ProxyMapT
typedef intrusive_ptr< Reactor >	ReactorPtr
typedef BasicBloomFilter	BloomFilter
typedef BasicBloomFilterWithChecksum	BloomFilterWithChecksum
typedef boost::intrusive_ptr < DiscreteRandomGenerator >	DiscreteRandomGeneratorPtr
typedef intrusive_ptr < DynamicBuffer >	DynamicBufferPtr
typedef intrusive_ptr< Filesystem >	FilesystemPtr
typedef boost::mutex::scoped_lock	ScopedLock
typedef boost::recursive_mutex::scoped_lock	ScopedRecLock
typedef PageArena	CharArena
typedef PageArena< unsigned char >	ByteArena
typedef std::vector< String >	Strings
typedef std::vector< int64_t >	Int64s
typedef std::vector< double >	Doubles
typedef Po::options_description	PropertiesDesc
typedef Po::positional_options_description	PositionalDesc
typedef intrusive_ptr< Properties >	PropertiesPtr
typedef const ScopeGuardImplBase &	ScopeGuard
	According to the C++ standard, a reference initialized with a temporary value makes that temporary value live for the lifetime of the reference itself.
typedef intrusive_ptr < StatsSystem >	StatsSystemPtr
typedef std::string	String
	We might want to use something better later, as std::string always causes a heap allocation, and is lacking in functionalities cf.
typedef long unsigned int	Lu
typedef long long unsigned int	Llu
typedef long long int	Lld
typedef intrusive_ptr < StringCompressorPrefix >	StringCompressorPrefixPtr
typedef intrusive_ptr < StringDecompressorPrefix >	StringDecompressorPrefixPtr
typedef boost::thread	Thread
typedef boost::thread_group	ThreadGroup
typedef intrusive_ptr < OpenFileData >	OpenFileDataPtr
typedef boost::intrusive_ptr < BlockCompressionCodec >	BlockCompressionCodecPtr
typedef PageArenaAllocator< Cell >	CellAlloc
typedef std::vector< Cell, CellAlloc >	Cells
typedef intrusive_ptr < CellsBuilder >	CellsBuilderPtr
typedef intrusive_ptr< Client >	ClientPtr
typedef intrusive_ptr< CommitLog >	CommitLogPtr
typedef std::deque < CommitLogFileInfo >	LogFragmentQueue
typedef intrusive_ptr < CommitLogBase >	CommitLogBasePtr
typedef intrusive_ptr < CommitLogBlockStream >	CommitLogBlockStreamPtr
typedef intrusive_ptr < CommitLogReader >	CommitLogReaderPtr
typedef intrusive_ptr< Future >	FuturePtr
typedef intrusive_ptr < HqlCommandInterpreter >	HqlCommandInterpreterPtr
typedef intrusive_ptr < HqlInterpreter >	HqlInterpreterPtr
typedef intrusive_ptr < IntervalScanner >	IntervalScannerPtr
typedef intrusive_ptr < IntervalScannerAsync >	IntervalScannerAsyncPtr
typedef boost::intrusive_ptr < LoadDataSource >	LoadDataSourcePtr
typedef intrusive_ptr < LocationCache >	LocationCachePtr
typedef intrusive_ptr < MasterClient >	MasterClientPtr
typedef intrusive_ptr < NameIdMapper >	NameIdMapperPtr
typedef intrusive_ptr< Namespace >	NamespacePtr
typedef intrusive_ptr < NamespaceCache >	NamespaceCachePtr
typedef intrusive_ptr < RangeLocator >	RangeLocatorPtr
typedef boost::intrusive_ptr < RangeServerClient >	RangeServerClientPtr
typedef std::pair< Cell, int >	FailedMutation
typedef std::vector < FailedMutation >	FailedMutations
typedef intrusive_ptr< Result >	ResultPtr
typedef intrusive_ptr < ResultCallback >	ResultCallbackPtr
typedef intrusive_ptr< ScanBlock >	ScanBlockPtr
typedef intrusive_ptr< ScanCells >	ScanCellsPtr
typedef PageArenaAllocator < RowInterval >	RowIntervalAlloc
typedef std::vector < RowInterval, RowIntervalAlloc >	RowIntervals
typedef PageArenaAllocator < CellInterval >	CellIntervalAlloc
typedef std::vector < CellInterval, CellIntervalAlloc >	CellIntervals
typedef PageArenaAllocator < const char * >	CstrAlloc
typedef std::vector< const char *, CstrAlloc >	CstrColumns
typedef intrusive_ptr< Schema >	SchemaPtr
typedef std::map< const char , StatsTable , LtCstr >	StatsTableMap
typedef intrusive_ptr < StatsRangeServer >	StatsRangeServerPtr
typedef intrusive_ptr< Table >	TablePtr
typedef intrusive_ptr< TableCache >	TableCachePtr
typedef intrusive_ptr < TableDumper >	TableDumperPtr
typedef intrusive_ptr < TableMutator >	TableMutatorPtr
typedef intrusive_ptr < TableMutatorIntervalHandler >	TableMutatorIntervalHandlerPtr
typedef CommAddressMap< uint32_t >	RangeServerFlagsMap
typedef intrusive_ptr < TableMutatorScatterBuffer >	TableMutatorScatterBufferPtr
typedef intrusive_ptr < TableMutatorSendBuffer >	TableMutatorSendBufferPtr
typedef intrusive_ptr < TableScanner >	TableScannerPtr
typedef intrusive_ptr < TableScannerAsync >	TableScannerAsyncPtr
typedef intrusive_ptr < TableScannerCallback >	TableScannerCallbackPtr
typedef boost::intrusive_ptr < TableScannerQueue >	TableScannerQueuePtr
typedef boost::shared_array < const char >	CharPtr
typedef intrusive_ptr< Context >	ContextPtr
typedef intrusive_ptr < DispatchHandlerOperation >	DispatchHandlerOperationPtr
typedef intrusive_ptr < DispatchHandlerOperationAlterTable >	DispatchHandlerOperationAlterTablePtr
typedef intrusive_ptr < DispatchHandlerOperationDropTable >	DispatchHandlerOperationDropTablePtr
typedef intrusive_ptr < DispatchHandlerOperationGetStatistics >	DispatchHandlerOperationGetStatisticsPtr
typedef CstrHashMap< int >	CountMap
typedef intrusive_ptr< Monitoring >	MonitoringPtr
typedef std::set< String >	DependencySet
typedef intrusive_ptr< Operation >	OperationPtr
typedef intrusive_ptr < OperationAlterTable >	OperationAlterTablePtr
typedef intrusive_ptr < OperationCollectGarbage >	OperationCollectGarbagePtr
typedef intrusive_ptr < OperationCreateNamespace >	OperationCreateNamespacePtr
typedef intrusive_ptr < OperationCreateTable >	OperationCreateTablePtr
typedef intrusive_ptr < OperationDropNamespace >	OperationDropNamespacePtr
typedef intrusive_ptr < OperationDropTable >	OperationDropTablePtr
typedef intrusive_ptr < OperationGatherStatistics >	OperationGatherStatisticsPtr
typedef intrusive_ptr < OperationGetSchema >	OperationGetSchemaPtr
typedef intrusive_ptr < OperationInitialize >	OperationInitializePtr
typedef intrusive_ptr < OperationMoveRange >	OperationMoveRangePtr
typedef intrusive_ptr < OperationProcessor >	OperationProcessorPtr
typedef intrusive_ptr < OperationRecoverServer >	OperationRecoverServerPtr
typedef intrusive_ptr < OperationRegisterServer >	OperationRegisterServerPtr
typedef intrusive_ptr < OperationRelinquishAcknowledge >	OperationRelinquishAcknowledgePtr
typedef intrusive_ptr < OperationRenameTable >	OperationRenameTablePtr
typedef intrusive_ptr < OperationStatus >	OperationStatusPtr
typedef intrusive_ptr < OperationSystemUpgrade >	OperationSystemUpgradePtr
typedef intrusive_ptr < OperationWaitForServers >	OperationWaitForServersPtr
typedef intrusive_ptr < RangeServerConnection >	RangeServerConnectionPtr
typedef std::map< String, RangeServerConnectionPtr >	RangeServerConnectionMap
typedef boost::intrusive_ptr < RangeServerState >	RangeServerStatePtr
typedef hash_map< String, RangeServerStatePtr >	RangeServerStateMap
typedef boost::intrusive_ptr < AccessGroup >	AccessGroupPtr
typedef std::set< Key, key_revision_lt >	KeySet
typedef intrusive_ptr< CellCache >	CellCachePtr
typedef PageArena< uint8_t, CellCachePageAllocator >	CellCacheArena
typedef boost::intrusive_ptr < CellList >	CellListPtr
typedef boost::intrusive_ptr < CellListScanner >	CellListScannerPtr
typedef intrusive_ptr< CellStore >	CellStorePtr
typedef intrusive_ptr < CellStoreV0 >	CellStoreV0Ptr
typedef intrusive_ptr < CellStoreV1 >	CellStoreV1Ptr
typedef intrusive_ptr < CellStoreV2 >	CellStoreV2Ptr
typedef intrusive_ptr < CellStoreV3 >	CellStoreV3Ptr
typedef intrusive_ptr < CellStoreV4 >	CellStoreV4Ptr
typedef intrusive_ptr < CellStoreV5 >	CellStoreV5Ptr
typedef boost::intrusive_ptr < GroupCommitInterface >	GroupCommitInterfacePtr
typedef boost::intrusive_ptr < GroupCommitTimerHandler >	GroupCommitTimerHandlerPtr
typedef intrusive_ptr < KeyCompressor >	KeyCompressorPtr
typedef intrusive_ptr < KeyCompressorNone >	KeyCompressorNonePtr
typedef intrusive_ptr < KeyCompressorPrefix >	KeyCompressorPrefixPtr
typedef intrusive_ptr < KeyDecompressor >	KeyDecompressorPtr
typedef intrusive_ptr < KeyDecompressorNone >	KeyDecompressorNonePtr
typedef intrusive_ptr < KeyDecompressorPrefix >	KeyDecompressorPrefixPtr
typedef hash_map< String, uint32_t >	FileRefCountMap
typedef boost::intrusive_ptr < LocationInitializer >	LocationInitializerPtr
typedef intrusive_ptr < MaintenancePrioritizer >	MaintenancePrioritizerPtr
typedef boost::intrusive_ptr < MaintenanceQueue >	MaintenanceQueuePtr
typedef intrusive_ptr < MaintenanceScheduler >	MaintenanceSchedulerPtr
typedef boost::intrusive_ptr < MergeScanner >	MergeScannerPtr
typedef intrusive_ptr< Range >	RangePtr
typedef intrusive_ptr < RangeServer >	RangeServerPtr
typedef intrusive_ptr< RangeSet >	RangeSetPtr
typedef std::vector < Range::MaintenanceData * >	RangeStatsVector
typedef intrusive_ptr < RangeStatsGatherer >	RangeStatsGathererPtr
typedef intrusive_ptr< RSStats >	RSStatsPtr
typedef intrusive_ptr < ScanContext >	ScanContextPtr
typedef intrusive_ptr < TableIdCache >	TableIdCachePtr
typedef intrusive_ptr< TableInfo >	TableInfoPtr
typedef boost::intrusive_ptr < TableInfoMap >	TableInfoMapPtr
typedef boost::intrusive_ptr < TimerHandler >	TimerHandlerPtr
typedef intrusive_ptr < CommandInterpreter >	CommandInterpreterPtr
typedef intrusive_ptr < CommandShell >	CommandShellPtr
typedef boost::intrusive_ptr < Notifier >	NotifierPtr
typedef intrusive_ptr < MasterCommandInterpreter >	MasterCommandInterpreterPtr
typedef intrusive_ptr < RangeServerCommandInterpreter >	RangeServerCommandInterpreterPtr
Enumerations
enum	Type { INTEGER, STRING, TIMESTAMP }
enum	Order { RANDOM, ASCENDING }
enum	{ LOCAL_FILE = 1, DFS_FILE, STDIN }
enum	BloomFilterMode { BLOOM_FILTER_DISABLED, BLOOM_FILTER_ROWS, BLOOM_FILTER_ROWS_COLS }
Functions
String	demangle (const String &mangled)
void	destruct (char *)
void	destruct (unsigned char *)
void	destruct (short *)
void	destruct (unsigned short *)
void	destruct (int *)
void	destruct (unsigned int *)
void	destruct (long *)
void	destruct (unsigned long *)
void	destruct (long long *)
void	destruct (unsigned long long *)
void	destruct (float *)
void	destruct (double *)
void	destruct (long double *)
template<typename T >
void	destruct (T *p)
size_t	get_align_offset (void *p)
void	append_as_byte_string (DynamicBuffer &dst_buf, const char *str)
void	append_as_byte_string (DynamicBuffer &dst_buf, const void *value, uint32_t value_len)
uint32_t	fletcher32 (const void *data, size_t len)
	Compute fletcher32 checksum for arbitary data.
uint32_t	fletcher32a (const uint16_t *data, size_t len)
	Compute fletcher32 checksum for 16-bit aligned and padded data slightly faster than fletcher32.
uint32_t	adler32_update_wp (uint32_t adler, const void *data8, size_t len)
uint32_t	adler32_wp (const void *data, size_t len)
uint32_t	adler32_update (uint32_t adler, const void *data, size_t len)
	Update adler32 checksum incrementally.
uint32_t	adler32 (const void *data, size_t len)
	Compute adler32 checksum.
uint32_t	crc32 (const void *data, size_t len)
	Compute crc32 checksum.
uint32_t	crc32_update (uint32_t crc, const void *data, size_t len)
	Update crc32 checksum incrementally.
size_t	hash_case_cstr (const char *s)
std::ostream &	operator<< (std::ostream &out, const Exception &e)
std::ostream &	operator<< (std::ostream &out, const ExceptionMessageRenderer &r)
std::ostream &	operator<< (std::ostream &out, const ExceptionMessagesRenderer &r)
std::ostream &	operator<< (std::ostream &out, const Endpoint &e)
std::ostream &	operator<< (std::ostream &out, const sockaddr_in &a)
uint32_t	hashword (const uint32_t *k, size_t length, uint32_t initval)
void	hashword2 (const uint32_t k, size_t length, uint32_t pc, uint32_t *pb)
uint32_t	hashlittle (const void *data, size_t len, uint32_t hash)
	The lookup3 hash from Bob Jenkins, a fast and strong 32-bit hash.
void	hashlittle2 (const void key, size_t length, uint32_t pc, uint32_t *pb)
uint32_t	hashbig (const void *key, size_t length, uint32_t initval)
uint32_t	murmurhash2 (const void *data, size_t len, uint32_t hash)
	The MurmurHash 2 from Austin Appleby, faster and better mixed (but weaker crypto-wise with one pair of obvious differential) than both Lookup3 and SuperFastHash.
template<typename CharT , class PageAlloc >
std::ostream &	operator<< (std::ostream &out, const PageArena< CharT, PageAlloc > &m)
void	intrusive_ptr_add_ref (ReferenceCount *rc)
	Atomically increments reference count.
void	intrusive_ptr_release (ReferenceCount *rc)
	Atomically decrements reference count, deleting the ReferenceCount object when the count reaches zero.
template<typename FunT >
ScopeGuardImpl0< FunT >	make_guard (FunT fun)
template<typename FunT , typename P1T >
ScopeGuardImpl1< FunT, P1T >	make_guard (FunT fun, P1T p1)
template<typename FunT , typename P1T , typename P2T >
ScopeGuardImpl2< FunT, P1T, P2T >	make_guard (FunT fun, P1T p1, P2T p2)
template<typename FunT , typename P1T , typename P2T , typename P3T >
ScopeGuardImpl3< FunT, P1T, P2T, P3T >	make_guard (FunT fun, P1T p1, P2T p2, P3T p3)
template<class ObjT , typename MethodT >
ObjScopeGuardImpl0< ObjT, MethodT >	make_obj_guard (ObjT &obj, MethodT method)
template<class ObjT , typename MethodT , typename P1T >
ObjScopeGuardImpl1< ObjT, MethodT, P1T >	make_obj_guard (ObjT &obj, MethodT method, P1T p1)
template<class ObjT , typename MethodT , typename P1T , typename P2T >
ObjScopeGuardImpl2< ObjT, MethodT, P1T, P2T >	make_obj_guard (ObjT &obj, MethodT method, P1T p1, P2T p2)
template<class T >
RefHolder< T >	by_ref (T &t)
bool	operator< (const StaticBuffer &sb1, const StaticBuffer &sb2)
	Less than operator for StaticBuffer.
bool	operator== (const StaticBuffer &sb1, const StaticBuffer &sb2)
	Equality operator for StaticBuffer.
bool	operator!= (const StaticBuffer &sb1, const StaticBuffer &sb2)
	Inequality operator for StaticBuffer.
size_t	sgi_hash (const char *s)
	Hash function for strings found in SGI STL code Slower than TclHash, included for comparison purpose.
size_t	sgi_hash (const void *data, size_t len, size_t seed)
size_t	tr1_hash (const char *s)
	Hash function for strings found in STL TR1 code Slower than TclHash and SgiHash, included for comparison purpose.
size_t	tr1_hash (const void *data, size_t len, size_t seed)
String	format (const char *fmt,...) __attribute__((format(printf
	Return a String using printf like format facilities vanilla snprintf is about 1.5x faster than this, which is about: 10x faster than boost::format; 1.5x faster than std::string append (operator+=); 3.5x faster than std::string operator+;.
String	format_number (int64_t n, int sep= ',')
	Return decimal number string separated by a separator (default: comma) for every 3 digits.
String	format_bytes (size_t n, const void buf, size_t len, const char trailer="...")
	Return first n bytes of buffer with an optinal trailer if the size of the buffer exceeds n.
template<class SequenceT >
String	format_list (const SequenceT &seq, const char *sep=", ")
	Return a string presentation of a sequence.
uint32_t	superfasthash (const void *data, size_t len, uint32_t hash)
	The SuperFastHash from Paul Hsieh, recommended by google sparse hash folks.
const char *	system_info_lib_version ()
std::ostream &	system_info_lib_version (std::ostream &out)
std::ostream &	operator<< (std::ostream &out, const CpuInfo &i)
std::ostream &	operator<< (std::ostream &out, const CpuStat &s)
std::ostream &	operator<< (std::ostream &out, const MemStat &s)
std::ostream &	operator<< (std::ostream &out, const DiskStat &s)
std::ostream &	operator<< (std::ostream &out, const OsInfo &i)
std::ostream &	operator<< (std::ostream &out, const SwapStat &s)
std::ostream &	operator<< (std::ostream &out, const NetInfo &i)
std::ostream &	operator<< (std::ostream &out, const NetStat &s)
std::ostream &	operator<< (std::ostream &out, const ProcInfo &i)
std::ostream &	operator<< (std::ostream &out, const ProcStat &s)
std::ostream &	operator<< (std::ostream &out, const FsStat &s)
std::ostream &	operator<< (std::ostream &out, const TermInfo &i)
size_t	tcl_hash (const char *s)
	The Tcl hash by John Ousterhout Fast and acceptable for alpha numeric keys.
size_t	tcl_hash (const void *data, size_t len, size_t seed)
	Tcl hash for data with known length.
size_t	tcl_hash2 (const void *data, size_t len, size_t seed)
	Unrolled Tcl hash, up to 20% faster for longer (> 8 bytes) strings.
void	print_proc_stat ()
std::ostream &	operator<< (std::ostream &out, const TestStat &stat)
template<typename FunT >
void	serial_run (FunT fun, size_t n, bool proc_stat=false)
template<typename FunT >
void	parallel_run (FunT fun, size_t n, bool proc_stat=false)
template<typename FunT >
void	run_test (FunT fun, bool proc_stat=false, const Properties *props=0)
int64_t	get_ts64 ()
bool	xtime_add_millis (boost::xtime &xt, uint32_t millis)
bool	xtime_sub_millis (boost::xtime &xt, uint32_t millis)
int64_t	xtime_diff_millis (boost::xtime &early_xt, boost::xtime &late_xt)
std::ostream &	hires_ts (std::ostream &out)
std::ostream &	hires_ts_date (std::ostream &out)
int64_t	parse_ts (const char *ts)
const char *	version ()
std::ostream &	operator<< (std::ostream &os, const Cell &cell)
bool	operator< (const CommitLogFileInfo &x, const CommitLogFileInfo &y)
	Less than operator for LocationCacheKey.
ByteString	create_key (uint8_t flag, const char row, uint8_t column_family_code, const char column_qualifier, int64_t timestamp=AUTO_ASSIGN, int64_t revision=AUTO_ASSIGN)
	Builds an opaque key from a set of key components.
void	create_key_and_append (DynamicBuffer &dst_buf, uint8_t flag, const char row, uint8_t column_family_code, const char column_qualifier, int64_t timestamp, int64_t revision)
void	create_key_and_append (DynamicBuffer &dst_buf, const char *row)
std::ostream &	operator<< (std::ostream &os, const Key &key)
	Prints a one-line representation of the key to the given ostream.
std::ostream &	operator<< (std::ostream &os, const SerializedKey &serkey)
	Prints a one-line representation of the key to the given ostream.
std::ostream &	operator<< (std::ostream &os, const KeySpec &cell)
bool	operator< (const LocationCacheKey &x, const LocationCacheKey &y)
	Less than operator for LocationCacheKey.
bool	operator== (const LocationCacheKey &x, const LocationCacheKey &y)
	Equality operator for LocationCacheKey.
bool	operator!= (const LocationCacheKey &x, const LocationCacheKey &y)
	Equality operator for LocationCacheKey.
std::ostream &	operator<< (std::ostream &, const RangeState &)
std::ostream &	operator<< (std::ostream &os, const RowInterval &ri)
std::ostream &	operator<< (std::ostream &os, const CellInterval &ci)
std::ostream &	operator<< (std::ostream &os, const ScanSpec &scan_spec)
bool	operator== (const SerializedKey sk1, const SerializedKey sk2)
bool	operator!= (const SerializedKey sk1, const SerializedKey sk2)
bool	operator< (const SerializedKey sk1, const SerializedKey sk2)
bool	operator<= (const SerializedKey sk1, const SerializedKey sk2)
bool	operator> (const SerializedKey sk1, const SerializedKey sk2)
bool	operator>= (const SerializedKey sk1, const SerializedKey sk2)
void	copy (TableDumper &, CellsBuilder &)
void	copy (TableDumperPtr &p, CellsBuilder &v)
void	copy (TableScanner &scanner, CellsBuilder &b)
std::ostream &	operator<< (std::ostream &os, const TableSplit &ts)
std::ostream &	operator<< (std::ostream &os, const TableIdentifier &tid)
std::ostream &	operator<< (std::ostream &os, const RangeSpec &range)
std::ostream &	operator<< (std::ostream &os, const AccessGroup::MaintenanceData &mdata)
std::ostream &	operator<< (std::ostream &os, CellStoreTrailer &trailer)
	ostream shift function for CellStoreTrailer objects
bool	FillScanBlock (CellListScannerPtr &scanner, DynamicBuffer &dbuf, int64_t buffer_size)
std::ostream &	operator<< (std::ostream &os, const Range::MaintenanceData &mdata)
Variables
char const *const	digits = "0123456789"
const int	version_major = HT_VERSION_MAJOR
const int	version_minor = HT_VERSION_MINOR
const int	version_micro = HT_VERSION_MICRO
const int	version_patch = HT_VERSION_PATCH
const std::string	version_misc_suffix = HT_VERSION_MISC_SUFFIX
static const uint32_t	FLAG_DELETE_ROW = 0x00
static const uint32_t	FLAG_DELETE_COLUMN_FAMILY = 0x01
static const uint32_t	FLAG_DELETE_CELL = 0x02
static const uint32_t	FLAG_INSERT = 0xFF
const int64_t	TIMESTAMP_MIN = INT64_MIN
const int64_t	TIMESTAMP_MAX = INT64_MAX
const int64_t	TIMESTAMP_NULL = INT64_MIN + 1
const int64_t	TIMESTAMP_AUTO = INT64_MIN + 2
const int64_t	AUTO_ASSIGN = INT64_MIN + 2

Detailed Description

Autogenerated by Thrift.

This file is part of Hypertable.

Hypertable is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or any later version.