| Package | Description | 
|---|---|
| com.bigdata.bfs | 
 
        This package provides a scale-out content repository (aka distributed file
        system) suitable as the backend for a REST-ful service using the bigdata
        architecture. 
 | 
| com.bigdata.bop.ap.filter | 
 
    These filters are based on the striterator patterns. 
 | 
| com.bigdata.bop.fed | |
| com.bigdata.bop.fed.nodes | |
| com.bigdata.bop.fed.shards | |
| com.bigdata.bop.join | |
| com.bigdata.bop.solutions | 
 
    This package provides distinct, sort, and aggregation operators. 
 | 
| com.bigdata.btree | 
 
The  
BTree is a scalable B+-Tree with copy-on-write
semantics mapping variable length unsigned byte[] keys to variable
length byte[] values (null values are allowed). | 
| com.bigdata.btree.data | |
| com.bigdata.btree.filter | |
| com.bigdata.btree.isolation | |
| com.bigdata.btree.proc | |
| com.bigdata.btree.view | |
| com.bigdata.counters.store | 
 
    This package provides a persistence mechanism for performance
    counters. 
 | 
| com.bigdata.htree | |
| com.bigdata.htree.data | |
| com.bigdata.journal | 
 
The journal is an append-only persistence capable data structure
supporting atomic commit, named indices, and transactions. 
 | 
| com.bigdata.mdi | 
 
This package provides a metadata index and range partitioned indices
managed by that metadata index. 
 | 
| com.bigdata.rdf.inf | 
 
This package provides an eager closure inference engine for most of the RDF and
RDFS entailments and can be used to realize entailments for owl:sameAs, owl:equivilentClass,
and owl:equivilentProperty. 
 | 
| com.bigdata.rdf.lexicon | |
| com.bigdata.rdf.load | 
 
Support for concurrent loading of RDF data across one or more clients from
a variety of input sources. 
 | 
| com.bigdata.rdf.rules | |
| com.bigdata.rdf.sail | 
 
This package contains the SAIL that allow bigdata to be used as a backend for
the Sesame 2.x platform. 
 | 
| com.bigdata.rdf.sparql.ast.eval | |
| com.bigdata.rdf.sparql.ast.service.history | |
| com.bigdata.rdf.spo | 
 
This package defines a statement model using long term identifiers rather than
RDF Value objects. 
 | 
| com.bigdata.rdf.util | |
| com.bigdata.relation | 
 
    This package includes an abstraction layer for relations. 
 | 
| com.bigdata.relation.accesspath | 
 
    This package includes an abstraction layer for efficient access paths, including
    chunked iterators, blocking buffers, and an abstraction corresponding to the natural
    order of an index. 
 | 
| com.bigdata.resources | 
 
  This package provides the logic to managed the live journal and the
  historical journals and index segments for a  
DataService. | 
| com.bigdata.search | 
 
This package provides full text indexing and search. 
 | 
| com.bigdata.service | 
 
This package provides implementations of bigdata services (metadata
service, data service, transaction manager service. 
 | 
| com.bigdata.service.geospatial | |
| com.bigdata.service.ndx | |
| com.bigdata.sparse | 
 
This package provides support for treating normal B+Trees using a
"sparse row store" pattern and can be applied to both local B+Trees
and scale-out indices. 
 | 
| com.bigdata.stream | 
| Class and Description | 
|---|
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IOverflowHandler
 An interface that allows you to inspect index entries during an
  
IndexSegmentBuilder operation. | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| Class and Description | 
|---|
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| Class and Description | 
|---|
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| Class and Description | 
|---|
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| Class and Description | 
|---|
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| Class and Description | 
|---|
| HTreeIndexMetadata
 HTree specific implementation. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| Class and Description | 
|---|
| BaseIndexStats
 Basic stats that are available for all index types and whose collection does
 not require visitation of the index pages. 
 | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| AbstractBTreeCursorTestCase
 Abstract base class for some unit tests that can only be run against a
  
BTree. | 
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| AbstractBTreeTupleCursor
 Class supporting random access to tuples and sequential tuple-based cursor
 movement for an  
AbstractBTree. | 
| AbstractBTreeTupleCursor.ReadOnlyBTreeTupleCursor | 
| AbstractChunkedTupleIterator
 A chunked iterator that proceeds a  
ResultSet at a time. | 
| AbstractIndexSegmentTestCase
 Adds some methods for testing an  
IndexSegment for consistency. | 
| AbstractNode
 Abstract node supporting incremental persistence and copy-on-write semantics. 
 | 
| AbstractTuple
 Abstract base class with much of the functionality of  
ITuple. | 
| AbstractTupleCursorTestCase
 Abstract base class for  
ITupleCursor test suites. | 
| AsynchronousIndexWriteConfiguration
 Configuration for the asynchronous index write API. 
 | 
| BaseIndexStats
 Basic stats that are available for all index types and whose collection does
 not require visitation of the index pages. 
 | 
| BloomFilter
 Encapsulates the actual implementation class and provides the protocol for
 (de-)serialization. 
 | 
| BloomFilter.BloomFilterCounters
 Counters for bloom filter access and notification of false positives. 
 | 
| BloomFilterFactory
 An interface that is used to generate a bloom filter for an
  
AbstractBTree and which allows the caller to specify the expected
 number of index entries, the desired error rate for the filter at that #of
 index entries, and the maximum error rate before the bloom filter will be
 disabled. | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| BTree.LeafCursor
 A cursor that may be used to traversal  
Leafs. | 
| BTree.Stack
 A simple stack based on an array used to maintain hard references for the
 parent  
Nodes in the BTree.LeafCursor. | 
| BTreeCounters
 A helper class that collects statistics on an  
AbstractBTree. | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| DefaultEvictionListener
 Hard reference cache eviction listener writes a dirty node or leaf onto the
 persistence store. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| DelegateIndex
 An object that delegates its  
IIndex interface. | 
| HTreeIndexMetadata
 HTree specific implementation. 
 | 
| IAbstractNode
 Interface for a node or a leaf of a B+-Tree. 
 | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBloomFilter
 Interface for bloom filter implementations using an unsigned byte[] key. 
 | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| IBTreeUtilizationReport
 B+Tree utilization report. 
 | 
| ICheckpoint
 Metadata for an index checkpoint record. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| ICounter
 An interface for a counter. 
 | 
| IDirty
 An interface that declares how we access the dirty state of an object. 
 | 
| IDirtyListener
 An interface that may be used to learn when a  
BTree becomes
 dirty. | 
| IEvictionListener
 Interface to handle evictions of nodes or leaves from the hard reference
 queue. 
 | 
| IIdentityAccess
 An interface that declares how we access the persistent identity of an
 object. 
 | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILeafCursor
 Leaf cursor interface. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexInconsistentError
 Error marks an mutable index as in an inconsistent state. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IndexMetadata.Options
 Options and their defaults for the  
com.bigdata.btree package and
 the BTree and IndexSegment classes. | 
| IndexSegment
 An index segment is read-only btree corresponding to some key range of a
 potentially distributed index. 
 | 
| IndexSegment.ImmutableLeafCursor
 Cursor using the double-linked leaves for efficient scans. 
 | 
| IndexSegment.ImmutableNodeFactory.ImmutableLeaf
 Immutable leaf throws  
UnsupportedOperationException for the
 public mutator API but does not try to override all low-level
 mutation behaviors. | 
| IndexSegmentAddressManager
 
 Address manager supporting offsets that are encoded for one of several
 regions in an  
IndexSegmentStore. | 
| IndexSegmentBuilder
 Builds an  
IndexSegment given a source btree and a target branching
 factor. | 
| IndexSegmentBuilder.AbstractSimpleNodeData
 Abstract base class for classes used to construct and serialize nodes and
 leaves written onto the index segment. 
 | 
| IndexSegmentBuilder.SimpleLeafData
 A class that can be used to (de-)serialize the data for a leaf without
 any of the logic for operations on the leaf. 
 | 
| IndexSegmentBuilder.SimpleNodeData
 A class that can be used to (de-)serialize the data for a node without
 any of the logic for operations on the node. 
 | 
| IndexSegmentCheckpoint
 The checkpoint record for an  
IndexSegment. | 
| IndexSegmentPlan
 A plan for building a B+-Tree based on an input branching factor and #of
 entries. 
 | 
| IndexSegmentRegion
 Type-safe enumeration of the regions to which relative offsets may be
 constructed for an  
IndexSegmentStore. | 
| IndexSegmentStore
 A read-only store backed by a file containing a single  
IndexSegment. | 
| IndexTypeEnum
 Type safe enumeration of index types. 
 | 
| INodeFactory
 Interface for creating nodes or leaves. 
 | 
| IOverflowHandler
 An interface that allows you to inspect index entries during an
  
IndexSegmentBuilder operation. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IRawRecordAccess
 Interface providing access to raw records. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleSplitHandler
 Interface allows an application to constrain the choice of the separator
 key when an index partition is split. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleCursor
 Interface for sequential and random-access cursor-based  
ITuple
 operations on an index or index partition. | 
| ITupleCursor2
 Extended interface. 
 | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| KeyOutOfRangeException
 An exception thrown when the key is outside of the half-open range constraint
 for a  
ITupleCursor or an index partition. | 
| Leaf
 
 A B+-Tree leaf. 
 | 
| Leaf.ILeafListener
 An interface that may be used to register for and receive events when the
 state of a  
Leaf is changed. | 
| Node
 
 A non-leaf node. 
 | 
| NodeSerializer
 
 An instance of this class is used to serialize and de-serialize the
  
INodeDatas and ILeafDatas of an AbstractBTree. | 
| NOPBloomFilter
 A bloom filter that never reports  
false (this means that you
 must always check the index) and that does not permit anything to be added
 and, in fact, has no state. | 
| PageStats
 Class reports various summary statistics for nodes and leaves. 
 | 
| PO
 A persistent object. 
 | 
| ReadWriteLockManager
 Base class for managing read/write locks for unisolated  
ICommitters. | 
| ResultSet
 An object used to stream key scan results back to the client. 
 | 
| ScatterSplitConfiguration
 Configuration object for scatter split behavior for a scale-out index. 
 | 
| SeekEnum
 Typesafe enum used to indicate that an  
ILeafCursor should
 seek to the first or last leaf in the B+Tree. | 
| SimpleEntry
 Test helper provides an entry (aka value) for a  
Leaf. | 
| Tuple
 A key-value pair used to facilitate some iterator constructs. 
 | 
| Class and Description | 
|---|
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| AbstractTupleCursorTestCase
 Abstract base class for  
ITupleCursor test suites. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleCursor
 Interface for sequential and random-access cursor-based  
ITuple
 operations on an index or index partition. | 
| ITupleCursor2
 Extended interface. 
 | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| ICounter
 An interface for a counter. 
 | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| Class and Description | 
|---|
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBloomFilter
 Interface for bloom filter implementations using an unsigned byte[] key. 
 | 
| ICounter
 An interface for a counter. 
 | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleCursor
 Interface for sequential and random-access cursor-based  
ITuple
 operations on an index or index partition. | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| Tuple
 A key-value pair used to facilitate some iterator constructs. 
 | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| BaseIndexStats
 Basic stats that are available for all index types and whose collection does
 not require visitation of the index pages. 
 | 
| BTreeCounters
 A helper class that collects statistics on an  
AbstractBTree. | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| HTreeIndexMetadata
 HTree specific implementation. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| ICounter
 An interface for a counter. 
 | 
| IDirtyListener
 An interface that may be used to learn when a  
BTree becomes
 dirty. | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| PageStats
 Class reports various summary statistics for nodes and leaves. 
 | 
| PO
 A persistent object. 
 | 
| Class and Description | 
|---|
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| BaseIndexStats
 Basic stats that are available for all index types and whose collection does
 not require visitation of the index pages. 
 | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| BTreeCounters
 A helper class that collects statistics on an  
AbstractBTree. | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| DelegateBTree
 An object that delegates the  
IIndex and ILinearList
 interfaces. | 
| DelegateIndex
 An object that delegates its  
IIndex interface. | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Tuple
 A key-value pair used to facilitate some iterator constructs. 
 | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| DelegateIndex
 An object that delegates its  
IIndex interface. | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| ICheckpoint
 Metadata for an index checkpoint record. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| Class and Description | 
|---|
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| FixedLengthPrefixSplits
 Imposes constraint that the key before the separatorKey must differ in
 the first N bytes from the key after the separator key. 
 | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| ISimpleSplitHandler
 Interface allows an application to constrain the choice of the separator
 key when an index partition is split. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| Class and Description | 
|---|
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| AbstractNode
 Abstract node supporting incremental persistence and copy-on-write semantics. 
 | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| Class and Description | 
|---|
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| Class and Description | 
|---|
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IndexSegment
 An index segment is read-only btree corresponding to some key range of a
 potentially distributed index. 
 | 
| ISimpleSplitHandler
 Interface allows an application to constrain the choice of the separator
 key when an index partition is split. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| Class and Description | 
|---|
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| Class and Description | 
|---|
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| BTreeCounters
 A helper class that collects statistics on an  
AbstractBTree. | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IndexSegment
 An index segment is read-only btree corresponding to some key range of a
 potentially distributed index. 
 | 
| IndexSegmentBuilder
 Builds an  
IndexSegment given a source btree and a target branching
 factor. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleSplitHandler
 Interface allows an application to constrain the choice of the separator
 key when an index partition is split. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| ResultSet
 An object used to stream key scan results back to the client. 
 | 
| Class and Description | 
|---|
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| AbstractBTree
 
 Base class for mutable and immutable B+-Tree implementations. 
 | 
| AbstractBTreeTestCase
 Abstract test case for  
BTree tests. | 
| BTree
 
 This class implements a variant of a B+Tree in which all values are stored in
 leaves, but the leaves are not connected with prior-next links. 
 | 
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| IBTreeStatistics
 Interface used to report out some statistics about a B+Tree. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| ILinearList
 Interface for methods that return or accept an ordinal index into the entries
 in the B+-Tree. 
 | 
| ILocalBTreeView
 Interface indicates that the index is local rather than remote. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
| ISimpleTreeIndexAccess
 Extended interface for tree-structured indices. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| ResultSet
 An object used to stream key scan results back to the client. 
 | 
| UnisolatedReadWriteIndex
 
 A view onto an unisolated index partition which enforces the constraint that
 either concurrent readers -or- a single writer may have access to the
 unisolated index at any given time. 
 | 
| Class and Description | 
|---|
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| Class and Description | 
|---|
| AbstractChunkedTupleIterator
 A chunked iterator that proceeds a  
ResultSet at a time. | 
| IAutoboxBTree
 An interface defining non-batch methods for inserting, removing, lookup, and
 containment tests where keys and values are implicitly converted to and from
  
byte[]s using the ITupleSerializer configured on the
 IndexMetadata object for the IIndex. | 
| ICounter
 An interface for a counter. 
 | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IIndexLocalCounter
 An interface for accessing an index local counter. 
 | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IRangeQuery
 Interface for range count and range query operations. 
 | 
| ISimpleBTree
 
 Interface for non-batch operations on a B+-Tree mapping non-null variable
 length unsigned byte[] keys to arbitrary values. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| ResultSet
 An object used to stream key scan results back to the client. 
 | 
| Class and Description | 
|---|
| DefaultTupleSerializer
 Default implementation uses the  
KeyBuilder to format the object as a
 key and uses Java default serialization for the value. | 
| IIndex
 
 Interface for mutable B+-Tree mapping arbitrary non-null keys to arbitrary
 values. 
 | 
| IndexSegment
 An index segment is read-only btree corresponding to some key range of a
 potentially distributed index. 
 | 
| ISimpleSplitHandler
 Interface allows an application to constrain the choice of the separator
 key when an index partition is split. 
 | 
| ITuple
 Interface exposes more direct access to keys and values visited by an
  
ITupleIterator. | 
| ITupleIterator
 Interface visits  
ITuples populated with the data and metadata for
 visited index entries. | 
| ITupleSerializer
 An interface that provides for the (de)-serialization of the value of a tuple
 stored in an index and, when possible, the key under which that value is
 stored. 
 | 
| Class and Description | 
|---|
| Checkpoint
 A checkpoint record is written each time the btree is flushed to the
 store. 
 | 
| ICheckpointProtocol
 Interface in support of the  
Checkpoint record protocol. | 
| IDirtyListener
 An interface that may be used to learn when a  
BTree becomes
 dirty. | 
| IndexMetadata
 
 The persistent and mostly immutable metadata for a  
AbstractBTree. | 
| IndexMetadata.Options
 Options and their defaults for the  
com.bigdata.btree package and
 the BTree and IndexSegment classes. | 
| IReadWriteLockManager
 Interface for managing read/write locks on persistence capable data
 structures. 
 | 
| ISimpleIndexAccess
 Generic data access methods defined for all persistence capable data
 structures. 
 | 
Copyright © 2006–2019 SYSTAP, LLC DBA Blazegraph. All rights reserved.