# All Classes

All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
A: Defines internal `typedef` for `GridArgumentCheck`.
AboutDialog: About dialog.
AbstractBaselineCommand
AbstractCachePartitionExchangeWorkerTask
AbstractClientIndex: Base class for all index implementations for Ignite client nodes.
AbstractConsistencyTask<A,​J>: Base class for Consistency tasks.
AbstractContinuousMessage
AbstractContinuousQuery<K,​V>: Base class for continuous query.
AbstractCreateSnapshotFutureTask
AbstractDataInnerIO
AbstractDataLeafIO
AbstractDataPageIO<T extends Storable>: Data pages IO.
AbstractDataPageIO.CC<T>: Defines closure interface for applying computations to data page items.
AbstractEvictionPolicy<K,​V>: Common functionality implementation for eviction policies with max size/max memory and batch eviction support.
AbstractEvictionPolicyFactory<T>: Common functionality implementation for eviction policies factories.
AbstractFailureHandler: Abstract superclass for `FailureHandler` implementations.
AbstractFileHandle
AbstractFileIO
AbstractFreeList<T extends Storable>
AbstractIndex: Abstract class for all Index implementations.
AbstractIndexDescriptorFactory: Abstract index descriptor factory (with helper methods).
AbstractInlineInnerIO: Inner page to store index rows with inlined keys.
AbstractInlineLeafIO: Leaf page to store index rows with inlined keys.
AbstractInnerIO: Inner page to store index rows.
AbstractLeafIO: Leaf page to store index rows.
AbstractMarshaller: Base class for marshallers.
AbstractMetric: Base class for `Metric` implementations.
AbstractNodeNameAwareMarshaller: Marshaller allowing for `Ignition.localIgnite()` calls.
AbstractPendingEntryInnerIO
AbstractPendingEntryLeafIO
AbstractScanQueryIterator<K,​V,​R>: Abstract scan query iterator.
AbstractSchemaChangeListener: Abstract schema change listener with no-op implementation for all calbacks.
AbstractSecurityAwareExternalizable<T>: Abstract security aware Externalizable.
AbstractSnapshotCommand<A extends IgniteDataTransferObject,​R>
AbstractSnapshotVerificationTask: The task for checking the consistency of snapshots in the cluster.
AbstractSnapshotVerificationTask.AbstractSnapshotVerificationJob
AbstractSslContextFactory: Represents abstract implementation of SSL Context Factory that caches the result of the first successful attempt to create an `SSLContext` and always returns it as a result of further invocations of the `AbstractSslContextFactory.create()`} method.
AbstractSystemViewExporterSpi: Basic class for `SystemViewExporterSpi` implementations.
AbstractTracingConfigurationCommand
AbstractWalRecordsIterator: Iterator over WAL segments.
AbstractWalRecordsIterator.AbstractFileDescriptor
AbstractWalRecordsIterator.AbstractReadFileHandle
AccessControllerSandbox: Sandbox that based on AccessController.
ActivateCommand: Deprecated.
AdaptiveCpuLoadProbe: Implementation of node load probing based on CPU load.
AdaptiveJobCountLoadProbe: Implementation of node load probing based on active and waiting job count.
AdaptiveLoadBalancingSpi: Load balancing SPI that adapts to overall node performance.
AdaptiveLoadBalancingSpiMBean: Management MBean for `AdaptiveLoadBalancingSpi` SPI.
AdaptiveLoadProbe: Pluggable implementation of node load probing.
AdaptiveProcessingTimeLoadProbe: Implementation of node load probing based on total job processing time.
AddressResolver: Provides resolution between external and internal addresses.
Affinity<K>: Provides affinity information to detect which node is primary and which nodes are backups for a partitioned or replicated cache.
AffinityAssignment: Cached affinity calculations.
AffinityCache: Affinity Cache.
AffinityCentralizedFunction: Annotation marker which identifies affinity function that must be calculated on one centralized node instead of independently on each node.
AffinityFunction: Cache key affinity which maps keys to nodes.
AffinityFunctionContext: Affinity function context.
AffinityKey<K>: Optional wrapper for cache keys to provide support for custom affinity mapping.
AffinityKeyMapped: Optional annotation to specify custom key-to-node affinity.
AffinityKeyMapper: Deprecated. Use `AffinityKeyMapped` or `CacheKeyConfiguration.setAffinityKeyFieldName(String)` instead.
AffinityTask: Affinity mapped task.
AffinityTopologyVersion
AffinityUuid: Guaranteed unique affinity-based key.
AlwaysFailoverSpi: Failover SPI that always reroutes a failed job to another node.
AlwaysFailoverSpiMBean: Management bean for `AlwaysFailoverSpi`.
AlwaysFalsePredicate<E>: Defines a predicate which accepts a parameter and always returns `false`
AlwaysTruePredicate<E>: Defines a predicate which accepts a parameter and always returns `true`
AlwaysTrueReducer<T>: Reducer which always returns `true` from `IgniteReducer.collect(Object)`
Argument: Fields marked with this annotation is command arguments.
ArgumentGroup: Defines commands arguments restriction.
ArgumentGroupsHolder: `Repeatable` container for `ArgumentGroup`.
AsyncFileIO: File I/O implementation based on `AsynchronousFileChannel`.
AsyncFileIOFactory: File I/O factory which uses `AsynchronousFileChannel` based implementation of FileIO.
AsyncFutureListener<V>: Wraps listener and executes it in specified executor.
AsyncSupportAdapter<T extends IgniteAsyncSupport>: Adapter for `IgniteAsyncSupport`.
AtomicConfiguration: Configuration for atomic data structures.
AtomicDataStructureProxy<V extends AtomicDataStructureValue>: Represents base class for atomic data structures.
AtomicDataStructureValue
AtomicIntegerFactoryCallable: Atomic integer factory.
AtomicLongMetric: Long metric implementation.
AtomicLongView: `IgniteAtomicLong` representation for a `SystemView`.
AtomicLongViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
AtomicReferenceView: `IgniteAtomicReference` representation for a `SystemView`.
AtomicReferenceViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
AtomicSequenceView: `IgniteAtomicSequence` representation for a `SystemView`.
AtomicSequenceViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
AtomicStampedView: `IgniteAtomicStamped` representation for a `SystemView`.
AtomicStampedViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
AttributeNames: Deprecated. fix it in the ticket https://ggsystems.atlassian.net/browse/GG-29546
AttributeNodeFilter: Implementation of `IgnitePredicate<ClusterNode>` based on `user attributes`.
AuthenticationCommandHandler: Authentication handler.
AuthenticationContext: Authentication context.
BaselineAddCommand
BaselineAddCommandArg
BaselineAdjustForbiddenException: Exception which would be throw during force changing baseline if cluster has incorrect configuration.
BaselineAutoAdjustCommand
BaselineAutoAdjustCommandArg
BaselineAutoAdjustCommandArg.Enabled
BaselineAutoAdjustMXBean: This interface defines JMX view on `DistributedBaselineConfiguration`.
BaselineAutoAdjustMXBeanImpl: `BaselineAutoAdjustMXBean` implementation.
BaselineAutoAdjustSettings
BaselineAutoAdjustStatus: Statistic of baseline auto-adjust.
BaselineAutoAdjustStatus.TaskState
BaselineChangedEvent: Baseline changed event.
BaselineCommand
BaselineCommand.BaselineTaskArg
BaselineCommandArg
BaselineConfigurationChangedEvent: Baseline configuration changed event.
BaselineNode: Interface representing a single node from baseline topology.
BaselineNode: Data transfer object for `BaselineNode`.
BaselineNode.ResolvedAddresses: Simple data class for storing (hostname, address) pairs
BaselineNodeAttributeView: Baseline node attribute representation for a `SystemView`.
BaselineNodeAttributeViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
BaselineNodeView: Baseline topology node representation for a `SystemView`.
BaselineNodeViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
BaselineRemoveCommand
BaselineRemoveCommandArg
BaselineSetCommand
BaselineSetCommandArg
BaselineTask: Task that will collect information about baseline topology and can change its state.
BaselineTaskResult: Result for `BaselineTask`.
BaselineTopology: BaselineTopology represents a set of "database nodes" - nodes responsible for holding persistent-enabled caches and persisting their information to durable storage.
BaselineTopologyHistory
BaselineTopologyHistoryItem
BaselineTopologyUpdater: Baseline topology updater with ability to watch of topology changes.
BaselineVersionCommand
BaselineVersionCommandArg
BasicAddressResolver: Basic implementation of `AddressResolver`.
BasicJdbcDialect: Basic implementation of dialect based on JDBC specification.
BasicJdbcIpFinderDialect: Basic JDBC dialect to use along with `TcpDiscoveryJdbcIpFinder`.
BasicRateLimiter: The simplified version of Google Guava smooth rate limiter. The primary feature of a rate limiter is its "stable rate", the maximum rate that is should allow at normal conditions.
BasicWarmupClosure: Basic warm-up closure which warm-ups cache operations.
BCrypt: BCrypt implements OpenBSD-style Blowfish password hashing using the scheme described in "A Future-Adaptable Password Scheme" by Niels Provos and David Mazieres.
BeforeNodeStartCommand<A extends IgniteDataTransferObject,​R>: Command that must be executed directly using `GridClientBeforeNodeStart` instance.
BigEndianAscendingWordDeserializer: A corresponding deserializer for `BigEndianAscendingWordSerializer`.
BigEndianAscendingWordSerializer: A serializer that writes a sequence of fixed bit-width 'words' to a byte array.
BinaryAbstractIdentityResolver: Abstract identity resolver with common routines.
BinaryAbstractInputStream: Binary abstract input stream.
BinaryAbstractOutputStream: Base binary output stream.
BinaryAbstractStream: Binary abstract stream.
BinaryArray: Binary object representing array.
BinaryArrayIdentityResolver: Identity resolver implementation which compares raw array content of the binary object.
BinaryBasicIdMapper: Base binary ID mapper implementation.
BinaryBasicNameMapper: Base binary name mapper implementation.
BinaryBuilderEnum
BinaryBuilderReader
BinaryByteBufferInputStream: Input stream over `ByteBuffer`.
BinaryCachingMetadataHandler: Simple caching metadata handler.
BinaryClassDescriptor: Binary class descriptor.
BinaryCollectionFactory<K>: Collection factory.
BinaryConfiguration: Configuration object for Ignite Binary Objects.
BinaryContext: Binary context.
BinaryContextHolder: Binary context holder.
BinaryEnumArray: Ignite distinguishes between array of objects and array of enums.
BinaryEnumCache: Cache for enum constants.
BinaryEnumObjectImpl: Binary enum object.
BinaryField: Binary object field.
BinaryFieldAccessor: Field accessor to speedup access.
BinaryFieldEx
BinaryFieldImpl: Implementation of binary field descriptor.
BinaryFieldMetadata: Binary field metadata.
BinaryHeapInputStream: Binary heap input stream.
BinaryHeapOutputStream: Binary heap output stream.
BinaryIdentityResolver: Interface to compute hash codes for new binary objects and compare them for equality.
BinaryIdMapper: Type and field ID mapper for binary objects.
BinaryInputStream: Binary input stream.
BinaryInternalMapper: Internal binary mapper.
BinaryInvalidTypeException: Exception indicating that class needed for deserialization of binary object does not exist.
BinaryLazyValue
Binarylizable: Interface that allows to implement custom serialization logic for binary objects.
BinaryMapFactory<K,​V>: Map factory.
BinaryMarshaller: Implementation of `Marshaller` that lets to serialize and deserialize all objects in the binary format.
BinaryMemoryAllocator: On-heap memory allocator.
BinaryMemoryAllocatorChunk: Memory allocator chunk.
BinaryMetadata: Binary metadata which is passed over a wire.
BinaryMetadataHandler: Binary metadata handler.
BinaryMetadataKey: Key for binary metadata.
BinaryMetadataUpdatedListener: Interface allows any component to register for events of binary metadata updates.
BinaryMetadataView: `BinaryMetadata` representation for the `SystemView`.
BinaryMetadataViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
BinaryMethodWriteReplacer: Write replacer based on method invocation.
BinaryModifiableLazyValue
BinaryNameMapper: Maps type and field names to different names.
BinaryNoopMetadataHandler: No-op metadata handler.
BinaryObject: Wrapper for binary object in binary format.
BinaryObjectBuilder: Binary object builder.
BinaryObjectBuilderImpl
BinaryObjectEx: Extended binary object interface.
BinaryObjectException: Exception indicating binary object serialization error.
BinaryObjectExImpl: Internal binary object interface.
BinaryObjectImpl: Binary object implementation.
BinaryObjectOffheapImpl: Binary object implementation over offheap memory
BinaryOffheapInputStream: Binary off-heap input stream.
BinaryOffheapOutputStream: Binary offheap output stream.
BinaryOutputStream: Binary output stream.
BinaryPlainBinaryObject
BinaryPositionReadable: Interface allowing for positioned read.
BinaryPrimitives: Primitives writer.
BinaryRawReader: Raw reader for binary objects.
BinaryRawReaderEx: Extended reader interface.
BinaryRawWriter: Raw writer for binary object.
BinaryRawWriterEx: Extended writer interface.
BinaryReader: Reader for binary objects used in `Binarylizable` implementations.
BinaryReaderExImpl: Binary reader implementation.
BinaryReaderHandles: Reader handles.
BinaryReaderHandlesHolder: Holder for handles.
BinaryReaderHandlesHolderImpl: Simple holder for handles.
BinaryReflectiveSerializer: Binary serializer which writes object fields using reflection.
BinarySchema: Schema describing binary object content.
BinarySchema.Builder: Schema builder.
BinarySchema.Confirmation: Order confirmation result.
BinarySchemaRegistry: Binary schema registry.
BinarySerializedFieldComparator: Compares fiels in serialized form when possible.
BinarySerializer: Interface that allows to implement custom serialization logic for binary objects.
BinaryStream: Binary stream.
BinaryThreadLocalContext: Contains thread-local data for binary marshalling.
BinaryTreeMap: Binary `TreeMap` wrapper.
BinaryTreeMapWriteReplacer: Binary `TreeMap` write replacer.
BinaryTreeSet: Binary `TreeSet` wrapper.
BinaryTreeSetWriteReplacer: Binary `TreeSet` write replacer.
BinaryType: Binary type meta data.
BinaryTypeConfiguration: Defines configuration properties for a specific binary type.
BinaryTypeImpl: Binary type implementation.
BinaryTypeProxy: Binary type proxy.
BinaryUtils: Binary utils.
BinaryWriteMode: Various write modes for binary objects.
BinaryWriter: Writer for binary object used in `Binarylizable` implementations.
BinaryWriteReplacer: Interface to perform write replace.
BinaryWriterExImpl: Binary writer implementation.
BinaryWriterHandles: Writer handles.
BinaryWriterSchemaHolder: Binary writer schema holder.
BitSetIntSet: Set of Integers implementation based on BitSet.
BitSetIterator: Iterator over set bits in `BitSet`.
BitUtil: A collection of bit utilities.
BitVector: A vector (array) of bits that is accessed in units ("registers") of `width` bits which are stored as 64bit "words" (`long`s).
BlockingSslHandler
BooleanGauge: Implementation based on primitive supplier.
BooleanIndexKey
BooleanInlineIndexKeyType: Inline index key implementation for inlining `Boolean` values.
BooleanMetric: Interface for the metrics that holds boolean primitive.
BooleanMetricImpl: Metric that holds boolean primitive.
BPlusInnerIO<L>: Abstract IO routines for B+Tree inner pages.
BPlusIO<L>: Abstract IO routines for B+Tree pages.
BPlusLeafIO<L>: Abstract IO routines for B+Tree leaf pages.
BPlusMetaIO: IO routines for B+Tree meta pages.
BPlusTree<L,​T extends L>: Abstract B+Tree
BPlusTree.Result: Operation result.
BPlusTree.TreeRowClosure<L,​T extends L>: A generic visitor-style interface for performing filtering/modifications/miscellaneous operations on the tree.
BPlusTree.TreeRowFactory<L,​T extends L>: Row factory from page memory.
BPlusTreeRuntimeException: This exception indicates that there's something wrong with B+Tree data integrity.
BufferedFileIO: The class implements a `FileIO` that allows to write bytes to the underlying `FileIO` without necessarily causing a call to the underlying system for each byte written.
BufferedFileIOFactory: File I/O factory which provides `BufferedFileIO` implementation of FileIO.
BulkLoadAckClientParameters: Bulk load parameters, which are parsed from SQL command and sent from server to client.
BulkLoadCacheWriter: A proxy, which stores given key+value pair to a cache.
BulkLoadContextCursor: A special FieldsQueryCursor subclass that is used as a sentinel to transfer data from bulk load (COPY) command to the JDBC or other client-facing driver: the bulk load batch processor and parameters to send to the client.
BulkLoadCsvFormat: A placeholder for bulk load CSV format parser options.
BulkLoadCsvParser: CSV parser for COPY command.
BulkLoadFormat: A superclass and a factory for bulk load format options.
BulkLoadParser: Bulk load file format parser superclass + factory of known formats.
BulkLoadProcessor: Bulk load (COPY) command processor used on server to keep various context data and process portions of input received from the client side.
BulkLoadStreamerWriter: A bulk load cache writer object that adds entries using `IgniteDataStreamer`.
BusyExecutor: Executor with busy run support.
ByteBufferBackedDataInput: ByteBuffer backed data input
ByteBufferBackedDataInputImpl: Byte buffer backed data input.
ByteBufferExpander: ByteBuffer wrapper for dynamically expand buffer size.
ByteIndexKey
ByteInlineIndexKeyType: Inline index key implementation for inlining `Byte` values.
BytesIndexKey
BytesInlineIndexKeyType: Inline index key implementation for inlining byte arrays.
C1<E1,​R>: Defines `alias` for `IgniteClosure` by extending it.
C2<E1,​E2,​R>: Defines `alias` for `IgniteBiClosure` by extending it.
C3<E1,​E2,​E3,​R>: Defines `alias` for `GridClosure3` by extending it.
CA: Defines `alias` for `GridAbsClosure` by extending it.
CacheAbstractJdbcStore<K,​V>: Implementation of `CacheStore` backed by JDBC.
CacheAbstractJdbcStore.EntryMapping: Entry mapping description.
CacheAbstractJdbcStore.TypeKind: Type kind.
CacheAffinityChangeMessage: CacheAffinityChangeMessage represent a message that switches to a new affinity assignmentafter rebalance is finished.
CacheAffinityConfiguration: Data transfer object for affinity configuration properties.
CacheAffinitySharedManager<K,​V>
CacheAtomicityMode: Cache atomicity mode controls whether cache should maintain fully transactional semantics or more light-weight atomic behavior.
CacheCheckIndexInlineSizesCommand: Check secondary indexes inline size.
CacheCheckpointSpi: This class defines cache-based implementation for checkpoint SPI.
CacheCheckpointSpiMBean: Management bean that provides general administrative and configuration information about cache checkpoint SPI.
CacheClassLoaderMarker: It's a marker interface for detecting GridCacheDeploymentManager$CacheClassLoader.
CacheClearCommand: Clear caches.
CacheClearCommandArg
CacheClientReconnectDiscoveryData: Discovery data sent from client reconnecting to cluster.
CacheClusterMetricsMXBeanImpl: MX bean that keeps support of JCache specification.
CacheCommand
CacheCommand.CacheHelpCommand: Prints out help for the cache command.
CacheConfiguration<K,​V>: This class defines grid cache configuration.
CacheConfiguration: Data transfer object for cache configuration properties.
CacheConfiguration.IgniteAllNodesPredicate: Filter that accepts all nodes.
CacheConfigurationCollectorJob: Job that collect cache configuration from node.
CacheConfigurationCollectorTask: Task that collect cache metrics from all nodes.
CacheConfigurationCollectorTaskArg: Argument for `CacheConfigurationCollectorTask`.
CacheConfigurationEnricher: The responsibility of this class is to enrich cache configuration with stored enrichment, in other words it allows to deserialize fields of `CacheConfiguration` that are marked with `SerializeSeparately`.
CacheConfigurationEnrichment: Object that contains serialized values for fields marked with `SerializeSeparately` in `CacheConfiguration`.
CacheConfigurationOverride: Helper class to override cache configuration.
CacheConfigurationSplitter: Splits cache configuration into two parts that can be serialized, deserialized separately.
CacheConfigurationSplitterImpl: Splits cache configuration into two parts that can be serialized, deserialized separately.
CacheConflictResolutionManager<K,​V>: Conflict resolver manager.
CacheConsistencyViolationEvent: This is an experimental API.
CacheConsistencyViolationEvent.EntriesInfo: Inconsistent entries mapping.
CacheConsistencyViolationEvent.EntryInfo: Inconsistent entry info.
CacheContentionCommand: Prints info about contended keys (the keys concurrently locked from multiple transactions).
CacheContentionCommandArg
CacheContinuousQueryBatchAck: Batch acknowledgement.
CacheContinuousQueryEntry: Continuous query entry.
CacheContinuousQueryEventBuffer
CacheContinuousQueryHandler<K,​V>: Continuous query handler.
CacheContinuousQueryHandlerV2<K,​V>: Continuous query handler V2 version.
CacheContinuousQueryHandlerV3<K,​V>: Continuous query handler V3 version.
CacheContinuousQueryListener<K,​V>: Continuous query listener.
CacheContinuousQueryManager<K,​V>: Continuous queries manager.
CacheContinuousQueryManager.CacheEntryEventImpl
CacheContinuousQueryManager.JCacheQueryRemoteFilter: For handler version 2.0 this filter should not be serialized.
CacheCreateCommand: Create caches.
CacheCreateCommandArg
CacheCreateTask: Task to create caches from Spring XML configuration.
CacheData: Cache information sent in discovery data to joining node.
CacheDataRow: Cache data row.
CacheDataRowAdapter: Cache data row adapter.
CacheDataRowAdapter.RowData
CacheDataRowStore
CacheDataStructuresManager
CacheDataTree
CacheDefaultBinaryAffinityKeyMapper
CacheDestroyCommand: Destroy caches.
CacheDestroyCommandArg
CacheDiagnosticManager: Component for manage all cache diagnostic functionality.
CacheDistributedGetFutureAdapter<K,​V>
CacheDistributionCommand: Collect information on the distribution of partitions.
CacheDistributionCommandArg
CacheDistributionGroup: DTO for CacheDistributionTask, contains information about group
CacheDistributionNode: DTO for CacheDistributionTask, contains information about node
CacheDistributionPartition: DTO for CacheDistributionTask, contains information about partition
CacheDistributionTask: Collect information on the distribution of partitions.
CacheDistributionTaskResult: Result of CacheDistributionTask
CacheEntry<K,​V>: Cache entry that extends `Cache.Entry` by providing additional entry related information.
CacheEntryEventAdapter<K,​V>
CacheEntryEventSerializableFilter<K,​V>: This filter adds `Serializable` interface to `CacheEntryEventFilter` object.
CacheEntryGetValueClosure: Cache entry to get-value transformer closure.
CacheEntryHasPeekPredicate: Cache entry has-peek-value predicate.
CacheEntryImpl<K,​V>
CacheEntryImpl0<K,​V>
CacheEntryImplEx<K,​V>
CacheEntryInfoCollection
CacheEntryPredicate
CacheEntryPredicateAdapter
CacheEntryPredicateContainsValue
CacheEntryPredicateHasValue
CacheEntryPredicateNoValue
CacheEntryProcessor<K,​V,​T>: This processor adds `Serializable` interface to `EntryProcessor` object.
CacheEntrySerializablePredicate
CacheEntryVersion: Entry event order.
CacheEvent: In-memory database (cache) event.
CacheEvictableEntryImpl<K,​V>: Entry wrapper that never obscures obsolete entries from user.
CacheEvictionConfiguration: Data transfer object for eviction configuration properties.
CacheEvictionEntry
CacheEvictionManager
CacheExistsException: Exception thrown when cache must be created but it already exists.
CacheFilterEnum: Represents a type of cache(s) that can be used for comparing update counters and checksums between primary and backup partitions.
CacheFindGarbageCommand: Find and remove garbage.
CacheFindGarbageCommandArg
CacheFreeList: FreeList implementation for cache.
CacheGetFuture
CacheGroupAffinityMessage: Information about affinity assignment.
CacheGroupContext
CacheGroupData
CacheGroupDescriptor
CacheGroupEncryptionTask<T>: Visor encrypted cache group multinode task.
CacheGroupEncryptionTask.ReencryptionBaseJob<T>
CacheGroupEncryptionTask.SingleFieldDto<T>
CacheGroupEncryptionTaskResult<T>: Multinode cache group encryption task result.
CacheGroupIoView: Cache group IO statistics representation for a `SystemView`.
CacheGroupIoViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
CacheGroupMetricsImpl: Cache group metrics.
CacheGroupPageScanner: Cache group page stores scanner.
CacheGroupView: Cache group representation for the `SystemView`.
CacheGroupViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
CacheIdAwareDataInnerIO
CacheIdAwareDataLeafIO
CacheIdAwarePendingEntryInnerIO
CacheIdAwarePendingEntryLeafIO
CacheIdleVerifyCommand: Checks consistency of primary and backup partitions assuming no concurrent updates are happening in the cluster.
CacheIdleVerifyCommandArg
CacheIdleVerifyDumpCommand
CacheIdleVerifyDumpCommandArg
CacheIndexesForceRebuildCommand: Index force rebuild.
CacheIndexesForceRebuildCommandArg
CacheIndexesListCommand: Index list.
CacheIndexesListCommandArg
CacheIndexesRebuildStatusCommand: Index rebuild status.
CacheIndexesRebuildStatusCommandArg
CacheInfo: Cache info DTO.
CacheInterceptor<K,​V>: Cache interceptor.
CacheInterceptorAdapter<K,​V>: Cache interceptor convenience adapter.
CacheInterceptorEntry<K,​V>: A cache interceptor map entry.
CacheInvalidStateException: This exception is used to indicate that requested operation is unavailable in current cache state.
CacheInvokeDirectResult
CacheInvokeEntry<K,​V>: Implementation of `MutableEntry` passed to the `EntryProcessor.process(MutableEntry, Object...)`.
CacheInvokeResult<T>: Implementation of `EntryProcessorResult`.
CacheIteratorConverter<T,​V>
CacheJavaObjectIndexKey
CacheJdbcBlobStore<K,​V>: `CacheStore` implementation backed by JDBC.
CacheJdbcBlobStoreFactory<K,​V>: `Factory` implementation for `CacheJdbcBlobStore`.
CacheJdbcPojoStore<K,​V>: Implementation of `CacheStore` backed by JDBC and POJO via reflection.
CacheJdbcPojoStoreFactory<K,​V>: `Factory` implementation for `CacheJdbcPojoStore`.
CacheJdbcStoreSessionListener: Cache store session listener based on JDBC connection.
CacheJdbcType: Data transfer object for `JdbcType`.
CacheJdbcTypeField: Data transfer object for `JdbcTypeField`.
CacheJoinNodeDiscoveryData: Information about configured caches sent from joining node.
CacheJoinNodeDiscoveryData.CacheInfo
CacheJtaManagerAdapter: Provides possibility to integrate cache transactions with JTA.
CacheKeyConfiguration: Configuration defining various aspects of cache keys without explicit usage of annotations on user classes.
CacheLazyEntry<K,​V>
CacheListCommand: Prints info regarding caches, groups or sequences.
CacheListCommand.OutputFormat
CacheListCommandArg
CacheLoadOnlyStoreAdapter<K,​V,​I>: This adapter designed to support stores with bulk loading from stream-like source.
CacheLocalStore: Deprecated. Use Apache Ignite Native Persistence in case of need of distributed persistence store.
CacheLockCandidates
CacheManager: Implementation of JSR-107 `CacheManager`.
CacheMetrics: Cache metrics used to obtain statistics on cache itself.
CacheMetricsCommand: Enable / disable cache metrics collection or show metrics collection status.
CacheMetricsCommandArg
CacheMetricsImpl: Adapter for cache metrics.
CacheMetricsImpl.EntriesStatMetrics: Entries and partitions metrics holder class.
CacheMetricsOperation: Enum for cache metrics command operations.
CacheMetricsSnapshot: Metrics snapshot.
CacheMetricsTask: Task for a cache metrics command.
CacheMode: Enumeration of all supported caching modes.
CacheNameResource: Annotates a field or a setter method for injection of grid cache name.
CacheNearConfiguration: Data transfer object for near cache configuration properties.
CacheNodeCommonDiscoveryData: Cache information sent in discovery data to joining node.
CacheNoopJtaManager: No-op implementation of `CacheJtaManagerAdapter`.
CacheObject
CacheObjectAdapter
CacheObjectBinaryProcessorImpl: Binary processor implementation.
CacheObjectBinaryProcessorImpl.TestBinaryContext
CacheObjectBinaryProcessorImpl.TestBinaryContext.TestBinaryContextListener
CacheObjectByteArrayImpl: Cache object over byte array.
CacheObjectContext
CacheObjectImpl
CacheObjectsReleaseFuture<T,​R>
CacheObjectTransformedEvent
CacheObjectTransformerProcessor: Provides cache object's bytes transformation (eg. encryption, compression, etc).
CacheObjectTransformerUtils
CacheObjectUtils: Cache object utility methods.
CacheObjectValueContext: Context to get value of cache object.
CacheOffheapEvictionManager
CacheOperationContext: Cache operation context.
CacheOperationFilter: Cache operation filter.
CacheOsConflictResolutionManager<K,​V>: OS conflict resolver manager.
CacheOsStoreManager: Default store manager implementation.
CachePagesListView: Pages-list representation for a `SystemView`.
CachePagesListViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
CachePartialUpdateCheckedException: Exception thrown from non-transactional cache in case when update succeeded only partially.
CachePartialUpdateException: Exception thrown from non-transactional cache in case when update succeeded only partially.
CachePartitionDefragmentationManager: Defragmentation manager is the core class that contains main defragmentation procedure.
CachePartitionExchangeWorkerTask: Cache partition exchange worker task marker interface.
CachePartitionFullCountersMap
CachePartitionPartialCountersMap
CachePeekMode: Enumeration of all supported cache peek modes.
CachePeekModes
CachePluginConfiguration<K,​V>: Cache plugin configuration.
CachePluginContext<C extends CachePluginConfiguration>: Cache plugin context.
CachePluginManager: Cache plugin manager.
CachePluginProvider<C extends CachePluginConfiguration>: Cache plugin provider is a point for processing of properties which provide specific `CachePluginConfiguration`.
CacheQuery<T>: Main API for configuring and executing cache queries.
CacheQueryEntryEvent<K,​V>: A Cache continuous query entry event.
CacheQueryExecutedEvent<K,​V>: Cache query execution event.
CacheQueryFieldsMetaResult: Cache query fields metadata.
CacheQueryFuture<T>: Cache query future returned by query execution.
CacheQueryObjectValueContext: Cache object value context for queries.
CacheQueryReadEvent<K,​V>: Cache query read event.
CacheQueryReducer<T>: This abstract class is base class for cache query reducers.
CacheQueryResult: Client query result.
CacheQueryType: Cache query type.
CacheRebalanceConfiguration: Data transfer object for cache rebalance configuration properties.
CacheRebalanceMode: Cache rebalance mode.
CacheRebalancingEvent: In-memory database (cache) rebalancing event.
CacheResetLostPartitionsCommand: Reset lost partitions.
CacheResetLostPartitionsCommandArg
CacheResetLostPartitionsTask: Reset status of lost partitions.
CacheResetLostPartitionsTaskResult: Result of CacheResetLostPartitionsTask
CacheScanCommand: Scan cache entries.
CacheScanCommandArg
CacheScanTask: Task that scan cache entries.
CacheScanTaskFormat: This is pluggable interface to customize string representation of cache data.
CacheScanTaskResult: Result of running `CacheScanTask`.
CacheScheduleIndexesRebuildCommand: Index rebuild via the maintenance mode.
CacheScheduleIndexesRebuildCommandArg
CacheSearchRow
CacheServerNotFoundException: Exception thrown when all data nodes left the grid.
CachesRegistry: Class is responsible to hold and persist cache and cache group descriptors.
CacheState
CacheStatisticsClearMessage: Cache statistics clear discovery message.
CacheStatisticsModeChangeMessage: Cache statistics mode change discovery message.
CacheStatisticsModeChangeTask: Cache statistics mode change task for exchange worker.
CacheStoppedException: Used to report attempts of accessing stopped cache.
CacheStopTask: Task that stop specified caches on specified node.
CacheStore<K,​V>: API for cache persistent storage for read-through and write-through behavior.
CacheStoreAdapter<K,​V>: Cache storage convenience adapter.
CacheStoreBalancingWrapper<K,​V>: Cache store wrapper that ensures that there will be no more that one thread loading value from underlying store.
CacheStoreConfiguration: Data transfer object for cache store configuration properties.
CacheStoreManager: Cache store manager interface.
CacheStorePartialUpdateException
CacheStoreSession: Session for the cache store operations.
CacheStoreSessionListener: Cache store session listener that allows to implement callbacks for session lifecycle.
CacheStoreSessionResource: Annotates a field or a setter method for injection of current `CacheStoreSession` instance.
CacheStripedExecutor: Wrapper over `StripedExecutor`, that groups submitted tasks by cache group and partition.
CacheTopologyValidatorProvider: The `CacheTopologyValidatorProvider` is used to pass an implementation of `TopologyValidator`s for a specific cache through Ignite plugin extensions mechanism.
CacheType
CacheValidateIndexesCommand: Validates indexes attempting to read each indexed entry.
CacheValidateIndexesCommandArg
CacheVersionConflictResolver: Cache version conflict resolver.
CacheVersionedValue: Cache object and version.
CacheVersionIO: Utility to read and write `GridCacheVersion` instances.
CacheView: Cache representation for a `SystemView`.
CacheViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
CacheWeakQueryIteratorsHolder<V>
CacheWeakQueryIteratorsHolder.WeakReferenceCloseableIterator<T>
CacheWriteSynchronizationMode: Mode indicating how Ignite should wait for write replies from other nodes.
CachingProvider: Implementation of JSR-107 `CachingProvider`.
CancellableTask: Runnable task with cancel method.
CancelServiceTask: Task for cancel services with specified name.
CAX: Defines `alias` for `GridAbsClosureX` by extending it.
CdcCacheDataResendTask: Task to forcefully resend all cache data to CDC.
CdcCacheEvent: Notification of `CdcConsumer` about cache creation/change events.
CdcCommand: Cdc commands.
CdcCommandLineStartup: This class defines command-line Ignite Capture Data Change startup.
CdcConfiguration: This class defines `CdcMain` runtime configuration.
CdcConsumer: Consumer of WAL data change events.
CdcConsumerState: Change Data Capture Consumer state.
CdcDataRecord: The record to forcefully resend cache data to the CDC application.
CdcDeleteLostSegmentLinksCommand: Command to delete lost segment links.
CdcDeleteLostSegmentLinksCommandArg
CdcDeleteLostSegmentsTask: Task to delete lost segment CDC links.
CdcEvent: Event of single entry change.
CdcEventImpl: Event of single entry change.
CdcFileLockHolder: Lock file holder for Change Data Capture application.
CdcLoader: Utility class to load `CdcMain` from Spring XML configuration.
CdcMain: Change Data Capture (CDC) application.
CdcManager: CDC manager responsible for logic of capturing data within Ignite node.
CdcManagerRecord: This record notifies `CdcMain` about committed WAL state.
CdcManagerStopRecord: Record notifies `CdcMain` that `CdcManager` fails and stop processing WAL data in-memory.
CdcMode: CDC modes.
CdcResendCommand: The command to forcefully resend all cache data to CDC.
CdcResendCommandArg
CdcUtilityActiveCdcManager: CDC manager that delegates consuming CDC events to the `CdcMain` utility.
CdcUtils: Methods to reuse various CDC like utilities.
ChangeCacheEncryptionRequest: Change cache group encryption key request.
ChangeCacheGroupKeyTask: The task for changing the encryption key of the cache group.
ChangeGlobalStateFinishMessage
ChangeGlobalStateMessage: Message represent request for change cluster global state.
ChangeMasterKeyTask: The task for changing the master key.
ChangeTagCommand: Change Cluster tag command.
ChangeTagCommandArg
CharsetDecoderBlock: A `PipelineBlock`, which converts stream of bytes supplied as byte[] arrays to an array of char[] using the specified encoding.
CheckCorruptedCacheStoresCleanAction
CheckCpHistTask: Task that checks whether last checkpoint is applicable for providing history for all groups and partitions that are passed as parameters.
CheckIndexInlineSizesResult: Represents information about secondary indexes inline size from the cluster nodes.
CheckIndexInlineSizesTask: Task for check secondary indexes inline size on the different nodes.
CheckpointContextImpl: Context with information about current checkpoint.
CheckpointEntry: Class represents checkpoint state.
CheckpointEntry.GroupState
CheckpointEntry.GroupStateLazyStore: Group state lazy store.
CheckpointEntryType: Checkpoint entry types.
Checkpointer: Checkpointer object is used for notification on checkpoint begin, predicate is `Checkpointer.scheduledCp``.nextCpTs - now > 0` .
CheckpointEvent: Grid checkpoint event.
CheckpointHistory: Checkpoint history.
CheckpointHistoryResult: Result of a checkpoint search and reservation.
CheckpointListener: Listener which methods will be called in a corresponded checkpoint life cycle period.
CheckpointListener: Listener for notifications of checkpoints removed by `CheckpointSpi`.
CheckpointListener.Context: Context with information about current snapshots.
CheckpointLockStateChecker: Interface for perform checking that checkpoint lock is held by current track
CheckpointManager: Main class to abstract checkpoint-related processes and actions and hide them from higher-level components.
CheckpointMarkersStorage: Abstraction responsible for managing checkpoint markers storage.
CheckpointMetricsTracker: Tracks various checkpoint phases and stats.
CheckpointPagesInfoHolder: Snapshot of dirty pages which should be stored to disk.
CheckpointPagesWriter: Implementation of page writer which able to store pages to disk during checkpoint.
CheckpointPagesWriter.CheckpointPageWriter: Interface which allows to write one page to page store.
CheckpointPagesWriterFactory: Factory class for checkpoint pages writer.
CheckpointProgress: Represents information of a progress of a current checkpoint and allows to obtain future to wait for a particular checkpoint state.
CheckpointProgressImpl: Data class representing the state of running/scheduled checkpoint.
CheckpointReadWriteLock: Wrapper of the classic read write lock with checkpoint features.
CheckpointRecord: Checkpoint (begin) record
CheckpointSpi: Checkpoint SPI provides an ability to save an intermediate job state.
CheckpointState: Possible checkpoint states.
CheckpointStatus: Checkpoint status which was restored from disk on node start.
CheckpointTimeoutLock: Checkpoint lock for outer usage which should be used to protect data during writing to memory.
CheckpointWorkflow: This class responsibility is to complement `Checkpointer` class with side logic of checkpointing like checkpoint listeners notifications, WAL records management and checkpoint markers management.
CheckpointWriteOrder: This enum defines order of writing pages to disk storage during checkpoint.
CI1<T>: Defines `alias` for `IgniteInClosure` by extending it.
CI2<E1,​E2>: Defines `alias` for `IgniteBiInClosure` by extending it.
CI3<E1,​E2,​E3>: Defines `alias` for `GridInClosure3` by extending it.
CircularStringBuilder: Basic string builder over circular buffer.
CIX1<T>: Defines `alias` for `IgniteInClosureX` by extending it.
CIX2<E1,​E2>: Defines `alias` for `IgniteInClosure2X` by extending it.
CIX3<E1,​E2,​E3>: Defines `alias` for `GridInClosure3X` by extending it.
ClassCache: Class cache.
ClassSet: Set of classes represented as prefix tree.
CleanCacheStoresMaintenanceAction
ClearCachesTask: Clears specified caches.
ClearCachesTaskResult: Result of `ClearCachesTask`.
CliConfirmArgument: Marks commands that must output example of optional `--yes` parameter.
ClientAddressFinder: This interface provides a list of addresses of Ignite server nodes within a cluster.
ClientAffinityTopologyVersion: Affinity topology version for thin client.
ClientAsyncResponse: Client async response.
ClientAtomicConfiguration: Configuration for atomic data structures.
ClientAtomicLong: Distributed atomic long API.
ClientAtomicLongCreateRequest: Gets or creates atomic long by name.
ClientAtomicLongExistsRequest: Atomic long exists request.
ClientAtomicLongImpl: Client atomic long.
ClientAtomicLongRemoveRequest: Atomic long remove request.
ClientAtomicLongRequest: Atomic long value request.
ClientAtomicLongValueAddAndGetRequest: Atomic long add and get request.
ClientAtomicLongValueCompareAndSetAndGetRequest: Atomic long compare and set and get request.
ClientAtomicLongValueCompareAndSetRequest: Atomic long compare and set request.
ClientAtomicLongValueGetAndSetRequest: Atomic long get and set request.
ClientAtomicLongValueGetRequest: Atomic long value request.
ClientAuthenticationException: Indicates user name or password is invalid.
ClientAuthorizationException: Indicates user has no permission to perform operation.
ClientAutoCloseableIterator<T>: Auto closeable iterator.
ClientBinary: Thin client implementation of `IgniteBinary`.
ClientBinaryConfigurationGetRequest: Binary configuration retrieval request.
ClientBinaryConfigurationGetResponse: Binary meta response.
ClientBinaryTypeGetRequest: Binary type schema request.
ClientBinaryTypeGetResponse: Binary meta response.
ClientBinaryTypeNameGetRequest: Gets binary type name by id.
ClientBinaryTypeNamePutRequest: Gets binary type name by id.
ClientBinaryTypePutRequest: Binary types update request.
ClientBitmaskFeature: Defines supported features for thin client.
ClientBooleanResponse: Boolean response.
ClientByteResponse: Byte response.
ClientCache<K,​V>: Thin client cache.
ClientCacheAffinityContext: Client cache partition awareness context.
ClientCacheAffinityMapping: Affinity mapping (partition to nodes) for each cache.
ClientCacheChangeDiscoveryMessage: Sent from cache client node to asynchronously notify about started.closed client caches.
ClientCacheChangeDummyDiscoveryMessage: Dummy discovery message which is not really sent via ring, it is just added in local discovery worker queue.
ClientCacheClearKeyRequest: Clear key request.
ClientCacheClearKeysRequest: Clear keys request.
ClientCacheClearRequest: Cache clear request.
ClientCacheConfiguration: Cache configuration.
ClientCacheConfigurationSerializer: Cache configuration serializer.
ClientCacheContainsKeyRequest: ContainsKey request.
ClientCacheContainsKeysRequest: ContainsKeys request.
ClientCacheCreateWithConfigurationRequest: Cache create with configuration request.
ClientCacheCreateWithNameRequest: Cache create with name request.
ClientCacheDestroyRequest: Cache destroy request.
ClientCacheEntryEventNotification: Continuous query notification.
ClientCacheEntryListenerHandler<K,​V>: Handler for `ContinuousQuery` listeners and JCache cache entry listeners.
ClientCacheEntryListenersRegistry: Per-cache cache entry listeners registry.
ClientCacheGetAllRequest: GetAll request.
ClientCacheGetAndPutIfAbsentRequest: Cache get and put if absent request.
ClientCacheGetAndPutRequest: Cache get and put request.
ClientCacheGetAndRemoveRequest: Cache get and remove request.
ClientCacheGetAndReplaceRequest: Cache get and replace request.
ClientCacheGetConfigurationRequest: Cache configuration request.
ClientCacheGetConfigurationResponse: Cache configuration response.
ClientCacheGetNamesRequest: Cache names request.
ClientCacheGetNamesResponse: Cache names response.
ClientCacheGetOrCreateWithConfigurationRequest: Cache get or create with configuration request.
ClientCacheGetOrCreateWithNameRequest: Cache create with name request.
ClientCacheGetRequest: Cache get request.
ClientCacheGetSizeRequest: Cache size request.
ClientCacheIndexQueryRequest: IndexQuery request.
ClientCacheInvokeAllRequest: Cache invokeAll request.
ClientCacheInvokeRequest: Cache invoke request.
ClientCacheInvokeRequest.EntryProcessorReader: Helper class to read entry processor and it's arguments.
ClientCacheKeyRequest: Cache request involving key.
ClientCacheKeysRequest: Key set request.
ClientCacheKeyValueRequest: Cache request involving key and value.
ClientCacheLocalPeekRequest: Cache local peek request.
ClientCacheNodePartitionsRequest: Cluster node list request.
ClientCachePartitionMapping: Cache partition mapping.
ClientCachePartitionsRequest: Cluster node list request.
ClientCachePutAllConflictRequest: Client `TcpClientCache.putAllConflict(Map)` request.
ClientCachePutAllRequest: PutAll request.
ClientCachePutIfAbsentRequest: Cache put if absent request.
ClientCachePutRequest: Cache put request.
ClientCacheQueryContinuousHandle: Continuous query handle.
ClientCacheQueryContinuousRequest: Continuous query request.
ClientCacheQueryNextPageRequest: Query cursor next page request.
ClientCacheQueryRequest: Abstract query request.
ClientCacheRemoveAllConflictRequest: Client `TcpClientCache.removeAllConflict(Map)` request.
ClientCacheRemoveAllRequest: Cache removeAll request.
ClientCacheRemoveIfEqualsRequest: Cache remove request with value.
ClientCacheRemoveKeyRequest: Remove request.
ClientCacheRemoveKeysRequest: Remove keys request.
ClientCacheReplaceIfEqualsRequest: Cache replace request.
ClientCacheReplaceRequest: Cache replace request.
ClientCacheRequest: Cache request.
ClientCacheScanQueryRequest: Scan query request.
ClientCacheSqlFieldsQueryRequest: Sql query request.
ClientCacheSqlQueryRequest: Sql query request.
ClientCacheStopWarmupRequest: Stop warmup request.
ClientCloseableResource: Client closeable resource.
ClientCluster: Thin client cluster facade.
ClientClusterChangeStateRequest: Cluster status request.
ClientClusterGetStateRequest: Cluster status request.
ClientClusterGroup: Thin client cluster group facade.
ClientClusterGroupGetNodeIdsRequest: Cluster group get node identifiers request.
ClientClusterGroupGetNodeIdsResponse: Cluster group get nodes identifiers response.
ClientClusterGroupGetNodesDetailsRequest: Cluster group get nodes details request.
ClientClusterGroupGetNodesDetailsResponse: Cluster group get nodes details response.
ClientClusterGroupGetNodesEndpointsRequest: Cluster group get nodes endpoints request.
ClientClusterGroupGetNodesEndpointsResponse: Cluster group get nodes endpoints response.
ClientClusterGroupProjection: Client cluster group projection representation.
ClientClusterImpl: Implementation of `ClientCluster`.
ClientClusterWalChangeStateRequest: Change cache WAL state request.
ClientClusterWalGetStateRequest: Get cache WAL state request.
ClientCollectionConfiguration: Configuration for Ignite collections.
ClientCompute: Thin client compute facade.
ClientConfiguration: `TcpIgniteClient` configuration.
ClientConnectableNodePartitions: Address of the node, connectible for the thin client, associated with cache partitions info.
ClientConnection: Client connection: abstracts away sending and receiving messages.
ClientConnectionAttributeView: Client connection attribute system view row.
ClientConnectionAttributeViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ClientConnectionContext: Thin Client connection context.
ClientConnectionDropTask: Task to cancel client connection(s).
ClientConnectionException: Indicates all the Ignite servers specified in the client configuration are no longer available.
ClientConnectionMultiplexer: Client connection multiplexer: manages multiple connections with a shared resource pool (worker threads, etc).
ClientConnectionNodeRecoveryException: Indicates that node is unavailable due to recovery mode.
ClientConnectionStateHandler: Handles thin client connection state.
ClientConnectionView: Client connection system view row.
ClientConnectionViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ClientConnectorConfiguration: Client connector configuration.
ClientConnectorConfigurationEx: Extended client connector configuration.
ClientDataStreamerAddDataRequest: Adds data to the existing streamer.
ClientDataStreamerFlags: Data streamer flags.
ClientDataStreamerHandle: Streamer handle.
ClientDataStreamerStartRequest: Starts the data streamer.
ClientDisconnectListener: Client disconnected event listener.
ClientDiscoveryContext: Nodes discovery context for Ignite client.
ClientException: Common thin client unchecked exception.
ClientExceptionsUtils: Utils to analyze client-related exceptions.
ClientExecuteTaskRequest: Request to execute compute task.
ClientExecuteTaskResponse: Execute task response.
ClientFailEvent: Event, triggered when Ignite client is failed to start.
ClientFeatureNotSupportedByServerException: Feature not supported by server exception.
ClientFlag: Client response flag.
ClientGetClusterStateComputeRequest: Request for getting cluster state on client node.
ClientGetIdleTimeoutRequest: Get idle timeout request.
ClientIgniteSet<T>: Distributed Set.
ClientIgniteSetClearRequest: Clears the IgniteSet.
ClientIgniteSetCloseRequest: Closes the IgniteSet.
ClientIgniteSetExistsRequest: Checks if IgniteSet exists.
ClientIgniteSetGetOrCreateRequest: Ignite set get or update request.
ClientIgniteSetIteratorGetPageRequest: Ignite set iterator next page request.
ClientIgniteSetIteratorStartRequest: Ignite set iterator start request.
ClientIgniteSetKeyRequest: Base class for all IgniteSet single-key requests.
ClientIgniteSetKeysRequest: Base class for all IgniteSet single-key requests.
ClientIgniteSetRequest: Ignite set get or update request.
ClientIgniteSetSizeRequest: Gets IgniteSet size.
ClientIgniteSetValueAddAllRequest: Set addAll request.
ClientIgniteSetValueAddRequest: Set add request.
ClientIgniteSetValueContainsAllRequest: Set contains all request.
ClientIgniteSetValueContainsRequest: Set contains request.
ClientIgniteSetValueRemoveAllRequest: Set value remove all request.
ClientIgniteSetValueRemoveRequest: Set value remove request.
ClientIgniteSetValueRetainAllRequest: Set retain all request.
ClientIndex: We need indexes on non-affinity nodes.
ClientIndexDefinition: Define index for filtered or client node.
ClientIndexFactory: Factory for client index.
ClientIntResponse: Int response.
ClientLifecycleEvent: Marker interface for all client's lifecycle events.
ClientLifecycleEventListener
ClientListenerAbstractConnectionContext: Base connection context.
ClientListenerAsyncResponse: Client listener async response.
ClientListenerConnectionContext: SQL listener connection context.
ClientListenerMessageParser: Client listener message parser.
ClientListenerMetrics: Client listener metrics.
ClientListenerNioListener: Client message listener.
ClientListenerNioMessageParser: This class implements stream parser.
ClientListenerProcessor: Client connector processor.
ClientListenerProtocolVersion: Client listener protocol version.
ClientListenerRequest: Client listener command request.
ClientListenerRequestHandler: Client listener request handler.
ClientListenerRequestNoId: Client request with no ID.
ClientListenerResponse: Client listener response.
ClientListenerResponseSender: Client listener response result sender.
ClientLongResponse: Long response.
ClientMessage
ClientMessageDecoder: Decodes thin client messages from partial buffers.
ClientMessageHandler: Handles thin client responses and server -> client notifications.
ClientMessageParser: Thin client message parser.
ClientNotification: Server to client notification for some resource.
ClientObjectNotification: Notification with object payload.
ClientObjectResponse: Single object response.
ClientOperation: Operation codes.
ClientOperationType: Client operation type.
ClientOutgoingMessage: Thin client outgoing message (from server to client).
ClientPartitionAwarenessMapper: This function calculates the cache key to a partition mapping for each cache key.
ClientPartitionAwarenessMapperFactory: This factory is used on the client side and only when the partition awareness thin client feature is enabled.
ClientPlatform: Client platform codes.
ClientProcessorMXBean: Deprecated. Use managements API beans, instead.
ClientProtocolContext: Protocol context for thin client protocol.
ClientProtocolVersionFeature: Thin client feature that was introduced by introducing new protocol version.
ClientRawRequest: Raw request, produces a ClientResponse directly.
ClientReconnectedException: Indicates that previous connection was lost and a new connection established, which can lead to inconsistency of non-atomic operations.
ClientRequest: Thin client request.
ClientRequestHandler: Thin client request handler.
ClientResourceCloseRequest: Resource close request.
ClientResourceRegistry: Per-connection resource registry.
ClientResponse: Thin client response.
ClientRetryAllPolicy: Retry policy that always returns `true`.
ClientRetryNonePolicy: Retry policy that always returns `false`.
ClientRetryPolicy: Client retry policy determines whether client operations that have failed due to a connection issue should be retried.
ClientRetryPolicyContext: Retry policy context.
ClientRetryReadPolicy: Retry policy that returns true for all read-only operations that do not modify data.
ClientServerError: Ignite server failed to process client request.
ClientServiceDescriptor: Descriptor of `Service`.
ClientServiceDescriptorResponse: Service descriptor.
ClientServiceDescriptorsResponse: Service descriptors.
ClientServiceGetDescriptorRequest: Request to get service descriptor.
ClientServiceGetDescriptorsRequest: Request to get service descriptors.
ClientServiceInvokeRequest: Request to invoke service method.
ClientServiceMappingsResponse: Service topology response.
ClientServices: Thin client services facade.
ClientServiceTopologyRequest: Request topology of certain service.
ClientSetClusterStateComputeRequest: Request for the change cluster state from client node.
ClientSslUtils
ClientStartEvent: Event, triggered when Ignite client is started.
ClientStatus: Client status codes.
ClientStopEvent: Event, triggered when Ignite client is stopped.
ClientStringResponse: Single string response.
ClientTransaction: Thin client transaction.
ClientTransactionConfiguration: Thin client transactions configuration.
ClientTransactions: Thin client transactions facade.
ClientTxAwareRequest: Interface for transaction aware requests.
ClientTxContext: Client transaction context.
ClientTxEndRequest: End the transaction request.
ClientTxStartRequest: Start transaction request.
ClientTxSupport
ClientUtils: Shared serialization/deserialization utils.
CliSubcommandsWithPrefix: Required for `control.sh` backward compatibility.
ClockPageReplacementFlags: Clock page replacement algorithm implementation.
ClockPageReplacementPolicy: CLOCK page replacement policy implementation.
ClockPageReplacementPolicyFactory: `ClockPageReplacementPolicy` factory.
ClusterActivationEvent: Deprecated. Use `ClusterStateChangeEvent` instead.
ClusterCachesInfo: Logic related to cache discovery data processing.
ClusterChangeTagTask
ClusterChangeTagTaskResult
ClusterGraph: Class to represent cluster nodes avalaible connections as graph.
ClusterGroup: Defines a cluster group which contains all or a subset of cluster nodes.
ClusterGroupAdapter
ClusterGroupEmptyCheckedException: This exception defines illegal call on empty projection.
ClusterGroupEmptyException: This exception defines illegal call on empty cluster group.
ClusterGroupEx: Internal projection interface.
ClusterIdAndTag: Container class to send cluster ID and tag in disco data and to write them atomically to metastorage.
ClusterLocalNodeMetricsMXBeanImpl: Local node metrics MBean.
ClusterMetrics: This class represents runtime information on a cluster.
ClusterMetricsImpl: Cluster metrics proxy.
ClusterMetricsMXBean: Cluster metrics MBean.
ClusterMetricsMXBeanImpl: Cluster metrics MBean.
ClusterMetricsSnapshot: Implementation for `ClusterMetrics` interface.
ClusterMetricsUpdateMessage
ClusterNode: Interface representing a single cluster node.
ClusterNode: Data transfer object for `ClusterNode`.
ClusterNodeAttributeAffinityBackupFilter: Attribute-based affinity backup filter that forces each partition's primary and backup nodes to different hardware which is not expected to fail simultaneously, e.g., in AWS, to different "availability zones".
ClusterNodeAttributeColocatedBackupFilter: This class can be used as a `RendezvousAffinityFunction.affinityBackupFilter` to create cache templates in Spring that force each partition's primary and backup to be co-located on nodes with the same attribute value.
ClusterNodeGetIdClosure: Grid node to node ID transformer closure.
ClusterNodeLocalMapImpl<K,​V>: Implementation for node-local storage.
ClusterNodeView: Cluster node representation for a `SystemView`.
ClusterNodeViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ClusterProcessor
ClusterSnapshotRecord: ClusterSnapshot record.
ClusterStartNodeResult: Cluster start node result information.
ClusterStartNodeResultImpl: Implementation for cluster start node result.
ClusterState: Cluster states.
ClusterStateChangeEvent: Cluster state change event.
ClusterStateChangeStartedEvent: Cluster state change started event.
ClusterStateProvider: Deprecated. This class must be removed.
ClusterTagGenerator: Generator of default cluster tags.
ClusterTagUpdatedEvent: Event type indicating that cluster tag has been updated.
ClusterTopologyCheckedException: This exception is used to indicate error with grid topology (e.g., crashed node, etc.).
ClusterTopologyException: This exception is used to indicate error with the cluster topology (e.g., crashed node, etc.).
ClusterTopologyServerNotFoundException: Internal exception that is used to indicate that all server nodes have left the grid.
CO<T>: Defines `alias` for `IgniteOutClosure` by extending it.
CollectConflictPartitionKeysTask
CollectConflictPartitionKeysTask.CollectPartitionEntryHashesJob
CollectionConfiguration: Configuration for Ignite collections.
CollisionContext: Context for resolving collisions.
CollisionExternalListener: Listener to be set on `CollisionSpi` for notification of external collision events (e.g. job stealing).
CollisionJobContext: This interface defines set of operations that collision SPI implementation can perform on jobs that are either waiting or executing.
CollisionSpi: Collision SPI allows to regulate how grid jobs get executed when they arrive on a destination node for execution.
CollocatedQueueItemKey
CollocatedSetItemKey
ColumnConfigurationViewSupplier: Column configuration view supplier.
ColumnInformation: Information about table column.
ColumnLocalDataViewSupplier: Column local data view supplier.
ColumnPartitionDataViewSupplier: Column partition data view supplier.
ColumnStatistics: Values statistic in particular column.
ColumnStatisticsCollector: Collector to compute statistic by single column.
Command<A extends IgniteDataTransferObject,​R>: Management command interface.
CommandInvoker<A extends IgniteDataTransferObject>: Command invoker.
CommandLineRandomNumberGenerator: Generates a random number and prints it to the console.
CommandLineStartup: This class defines command-line Ignite startup.
CommandLineTransformer: This class is a workaround for a versatile problems with passing arguments to the Ignite Windows batch launcher scripts.
CommandMBean<A extends IgniteDataTransferObject,​R>: Bean expose single mamagement command via JMX interface.
CommandRegistryImpl<A extends IgniteDataTransferObject,​R>: All commands class names stored in registry must ends with `Command.CMD_NAME_POSTFIX`.
CommandsRegistry<A extends IgniteDataTransferObject,​R>: Registry that knows all of its subcommands.
CommandUtils: Utility class for management commands.
CommunicationDiscoveryEventListener: Listener on discovery events.
CommunicationFailureContext: Communication Failure Context.
CommunicationFailureResolver: Communication Failure Resolver.
CommunicationListener<T extends Serializable>: Listener SPI notifies IO manager with.
CommunicationListenerEx<T extends Serializable>: Extended communication SPI listener to provide `Channel` opened events.
CommunicationSpi<T extends Serializable>: Communication SPI is responsible for data exchange between nodes.
CommunicationTcpUtils: Common communication spi logic.
CommunicationWorker: Works with connections states.
CompactablePageIO: Page IO that supports compaction.
CompositeServiceCallInterceptor: Composite service call interceptor.
CompressionHandler
CompressionProcessor: Compression processor.
ComputeCancelSessionTask: Cancels given tasks sessions on all cluster nodes.
ComputeCommand<A extends IgniteDataTransferObject,​R>: Command that executed with some compute task.
ComputeExecutionRejectedException: This exception defines execution rejection.
ComputeGridMonitor: Monitor for updating task statuses.
ComputeJob: Defines executable unit for `ComputeTask`.
ComputeJobAdapter: Convenience adapter for `ComputeJob` implementations.
ComputeJobAfterSend: This annotation allows to call a method right after the job has been successfully sent for execution.
ComputeJobBeforeFailover: This annotation allows to call a method right before job is submitted to `FailoverSpi`.
ComputeJobContext: Context attached to every job executed on the grid.
ComputeJobContinuation: Defines continuation support for grid job context.
ComputeJobContinuationAdapter: Convenience adapter for `ComputeJob` implementations.
ComputeJobFailoverException: This runtime exception can be thrown from `ComputeJob.execute()` method to force job failover to another node within task topology.
ComputeJobMasterLeaveAware: Annotation for handling master node leave during job execution.
ComputeJobResult: Result of remote job which gets passed into `ComputeTask.result(ComputeJobResult, List)` method.
ComputeJobResultPolicy: This enumeration provides different types of actions following the last received job result.
ComputeJobSibling: Job sibling interface defines a job from the same split.
ComputeJobStatusEnum: Compute job status.
ComputeJobView: Compute job representation for a `SystemView`.
ComputeJobView.ComputeJobState: Compute job state.
ComputeJobViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ComputeLoadBalancer: Load balancer is used for finding the best balanced node according to load balancing policy.
ComputeMXBean: Deprecated. Use managements API beans, instead.
ComputeMXBeanImpl: ComputeMXBean implementation.
ComputeTask<T,​R>: Grid task interface defines a task that can be executed on the grid.
ComputeTaskAdapter<T,​R>: Convenience adapter for `ComputeTask` interface.
ComputeTaskCancelledCheckedException: This exception indicates that grid task was cancelled.
ComputeTaskCancelledException: This exception indicates that grid task was cancelled.
ComputeTaskContinuousMapper: Defines a mapper that can be used for asynchronous job sending.
ComputeTaskFuture<R>: This class defines a handler for asynchronous task execution.
ComputeTaskInternalFuture<R>: This class provide implementation for task future.
ComputeTaskMapAsync: Annotation for asynchronous task mapping.
ComputeTaskName: This annotation allows to assign optional name to grid task.
ComputeTaskNoResultCache: This annotation disables caching of task results when attached to `ComputeTask` class being executed.
ComputeTaskSession: Defines a distributed session for particular task execution.
ComputeTaskSessionAttributeListener: This interface defines listener for task session attributes.
ComputeTaskSessionFullSupport: Annotation for enabling task session attributes and checkpoints for tasks.
ComputeTaskSessionScope: Defines life-time scopes for checkpoint operations.
ComputeTaskSpis: This annotation allows task to specify what SPIs it wants to use.
ComputeTaskSplitAdapter<T,​R>: This class defines simplified adapter for `ComputeTask`.
ComputeTaskStatus: Task status container.
ComputeTaskStatusEnum: Task status.
ComputeTaskStatusSnapshot: Snapshot of the task status.
ComputeTaskTimeoutCheckedException: This exception indicates that task execution timed out.
ComputeTaskTimeoutException: This exception indicates that task execution timed out.
ComputeTaskView: Compute task representation for a `SystemView`.
ComputeTaskViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ComputeUserUndeclaredException: This exception is thrown when user's code throws undeclared runtime exception.
ConcurrentHashMap8<K,​V>: Deprecated. need for java deserialization ConcurrentHashMap8 from old nodes.
ConcurrentHashSetFactoryCallable: Concurrent hash set factory.
ConcurrentLinkedDeque8<E>: An unbounded concurrent deque based on linked nodes.
ConcurrentLinkedDeque8.Node<E>
ConcurrentLinkedHashMap<K,​V>: A hash table supporting full concurrency of retrievals and adjustable expected concurrency for updates.
ConcurrentLinkedHashMap.HashEntry<K,​V>: ConcurrentHashMap list entry.
ConcurrentLinkedHashMap.QueuePolicy: Defines queue policy for this hash map.
ConcurrentMapFactoryCallable: Concurrent hash map factory.
ConfigurableHistogramMetric: Histogram metric with configurable bounds.
ConfigurationView: Configuration value representation for a `SystemView`.
ConfigurationViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ConnectFuture: Connect future which uses as a marker of type connection releted with TCP.
ConnectGateway: Lock and error control work flow.
ConnectionClientPool: Registry of client connections.
ConnectionClosedEvent
ConnectionDescription
ConnectionEvent
ConnectionEventListener
ConnectionKey: Connection Key.
ConnectionPolicy: Connection policy.
ConnectionProperties: Provide access and manipulations with connection JDBC properties.
ConnectionPropertiesImpl: Holds JDBC connection properties.
ConnectionRequestFuture: Marker future implementation, just like `ConnectFuture`, but meaning that we're waiting for the inverse connection.
ConnectionRequestor: Helper interface to ask other nodes to open connections.
ConnectivityResult: Connectivity task result
ConnectivityTask: Visor task that checks connectivity status between nodes.
ConnectorConfiguration: REST access configuration.
ConnectorMessageInterceptor: Interface for user-defined object interceptors.
ConsistencyCancelTask: Cancels given consistency repairs on all cluster nodes.
ConsistencyCommand: Command to check/repair consistency.
ConsistencyCountersFinalizationTask
ConsistencyFinalizeCommand
ConsistencyRepairCommand
ConsistencyRepairCommandArg
ConsistencyRepairTask
ConsistencyStatusCommand
ConsistencyStatusTask
ConsistencyTaskResult
ConsistentIdMapper: Class is needed for map UUID to consistent id and vice versa.
ContainsNodeIdsPredicate<T extends ClusterNode>: Grid node predicate evaluating on the given node IDs.
ContainsPredicate<T>: Predicate which returns `true` if it receives an element that is contained in the passed in collection.
ContentionClosure
ContentionInfo
ContentionJobResult
ContentionTask
ContentionTaskResult
ContinuousQuery<K,​V>: API for configuring continuous cache queries.
ContinuousQueryCancelTask: Task to cancel continuous query.
ContinuousQueryView: Continuous query representation for a `SystemView`.
ContinuousQueryViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ContinuousQueryWithTransformer<K,​V,​T>: API for configuring continuous cache queries with transformer.
ContinuousQueryWithTransformer.EventListener<T>: Interface for local listener of `ContinuousQueryWithTransformer` to implement.
ContinuousRoutinesCommonDiscoveryData
ContinuousRoutinesJoiningNodeDiscoveryData
ContinuousRoutineStartResultMessage
CorruptedDataStructureException: Abstract exception when `DataStructure` are corrupted.
CorruptedFreeListException: Exception to distinguish `AbstractFreeList` broken invariants.
CorruptedPartitionMetaPageException: Exception to distinguish partition meta page broken invariants.
CorruptedPdsMaintenanceCallback
CorruptedTreeException: Exception to distinguish `BPlusTree` tree broken invariants.
CountDownFuture
CountDownLatchView: `IgniteCountDownLatch` representation for a `SystemView`.
CountDownLatchViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
CounterSkipContext
COX<T>: Defines `alias` for `IgniteOutClosureX` by extending it.
CreateDumpFutureTask: Task creates cache group dump.
CrossObjectReferenceResolver
CsvLineProcessorBlock: A `PipelineBlock`, which splits line according to CSV format rules and unquotes fields.
CU: Defines internal `typedef` for `GridCacheUtils`.
CustomEventListener<T extends DiscoveryCustomMessage>: Listener interface.
CustomMessageWrapper
CX1<E1,​R>: Defines `alias` for `IgniteClosureX` by extending it.
CX2<E1,​E2,​R>: Defines `alias` for `IgniteClosure2X` by extending it.
CX3<E1,​E2,​E3,​R>: Defines `alias` for `GridClosure3X` by extending it.
CycleThread: Thread wrapper for standart cycle operations.
D: Convenience alias for `GridDebug` class.
DatabaseLifecycleListener
DataEntry: Represents Data Entry (`DataEntry.key`, `value`) pair update `operation` in WAL log.
DataInnerIO
DataLeafIO
DataPageEvictionMode: Defines memory page eviction algorithm.
DataPageInsertFragmentRecord: Insert fragment (part of big object which is bigger than page size) to data page record.
DataPageInsertRecord: Insert into data page.
DataPageIO: Data pages IO.
DataPagePayload
DataPageRemoveRecord
DataPageSetFreeListPageRecord
DataPageUpdateRecord: Update existing record in data page.
DataRecord: Logical data record with cache operation description.
DataRegion: Data region provides access to objects configured with `DataRegionConfiguration` configuration.
DataRegionConfiguration: This class allows defining custom data regions' configurations with various parameters for Apache Ignite page memory (see `DataStorageConfiguration`.
DataRegionMetrics: Deprecated. Check the `ReadOnlyMetricRegistry` with "name=io.dataregion.
DataRegionMetricsAdapter: Deprecated. Check the `ReadOnlyMetricRegistry` with "name=io.dataregion.
DataRegionMetricsImpl
DataRegionMetricsProvider: This interface provides calculated metrics for data region.
DataRegionMetricsSnapshot
DataRow
DataRowCacheAware: Data row implementation that can optionally hide the cache identifier and can set `null` as value. It is used to simplify storing a data row into page memory, because in some cases the cache identifier is not stored on the data pages, but is required to link this data row in `BPlusTree`.
DataStorageConfiguration: A durable memory configuration for an Apache Ignite node.
DataStorageMetricsImpl
DataStorageMXBean: An MX bean allowing to monitor and tune persistence.
DataStorageMXBeanImpl: TransactionsMXBean implementation.
DataStreamerCacheUpdaters: Bundled factory for cache updaters.
DataStreamerCacheUpdaters.InternalUpdater: Marker interface for updaters which do not need to unwrap cache objects.
DataStreamerEntry
DataStreamerImpl<K,​V>: Data streamer implementation.
DataStreamerImpl.IsolatedUpdater: Isolated receiver which only loads entry initial value.
DataStreamerRequest
DataStreamerResponse
DataStreamerUpdatesHandler: A snapshot haldler that monitors and warns of inconsistent by nature updates from DataStreamer which can issue data inconsistency in snapshot.
DataStreamProcessor<K,​V>: Data stream processor.
DataStructure: Base class for all the data structures based on `PageMemory`.
DataStructureInfoKey: Key used to store in utility cache information about created data structures.
DataStructuresCacheKey: Internal key for data structures processor.
DataStructuresCommandHandler
DataStructuresProcessor: Manager of data structures.
DataStructuresRequest
DataStructureType
DateIndexKey
DateInlineIndexKeyType: Inline index key implementation for inlining `DateIndexKey` values.
DateTimeIndexKey: Class that represnts a date/time index key.
DateValueUtils: DateValue is a representation of a date in bit form: dv = (year << SHIFT_YEAR) | (month << SHIFT_MONTH) | day.
DB2Dialect: A dialect compatible with the IBM DB2 database.
DeactivateCommand: Deprecated.
DeactivateCommandArg
DecimalIndexKey
DefaultCacheScanTaskFormat: Default cache scan task format.
DefaultCommunicationFailureResolver: Default Communication Failure Resolver.
DeferredSpan: Encapsulates concept of a deferred-initialized span.
DefragIndexFactory: Creates temporary index to defragment old index.
DefragIndexFactory.DefragIndexRowImpl: IndexRowImpl with index values stored in a byte array.
DefragmentationCancelCommand
DefragmentationCommand: Command to manage PDS defragmentation.
DefragmentationCommand.DefragmentationCancelCommandArg
DefragmentationCommand.DefragmentationStatusCommandArg
DefragmentationFileUtils: Everything related to file management during defragmentation process.
DefragmentationMXBean: Deprecated. Use managements API beans, instead.
DefragmentationMXBeanImpl: Defragmentation MX bean implementation.
DefragmentationPageReadWriteManager
DefragmentationParameters: Maintenance task for defragmentation.
DefragmentationScheduleCommand
DefragmentationScheduleCommandArg
DefragmentationStatusCommand
DefragmentationTask
DefragmentationTaskResult
DefragmentationWorkflowCallback: Defragmentation specific callback for maintenance mode.
DelayedDirtyPageStoreWrite: Not thread safe and stateful class for page replacement of one page with write() delay.
DelayedPageReplacementTracker: Delayed page writes tracker.
DeltaApplicationException: Thrown in case when delta application to the page failed.
DependencyResolver: The interface specifies a container of dependencies.
DeploymentEvent: Grid deployment event.
DeploymentListener: Listener for deployment events.
DeploymentMode: Grid deployment mode.
DeploymentResource: Generic abstraction over deployed resource containing resource's name, class and corresponding class loader.
DeploymentResourceAdapter: Simple adapter for `DeploymentResource` interface.
DeploymentSpi: Grid deployment SPI is in charge of deploying tasks and classes from different sources.
DetachedClusterNode: Representation of cluster node that either isn't currently present in cluster, or semantically detached.
DetachedPropertyException: Exception of distributed property still have not been attached to the processor.
DiagnosticCommand
DiagnosticCommand.DiagnosticHelpCommand
DiagnosticConnectivityCommand
DiagnosticConnectivityCommandArg
DiagnosticPagelocksCommand
DiagnosticPagelocksCommandArg
DiagnosticProcessor: Processor which contained helper methods for different diagnostic cases.
DirectBufferCleaner: Cleaner interface for `java.nio.ByteBuffer`.
DirectByteBufferStream: Direct marshalling I/O stream.
DirectMemoryProvider: Direct memory provider interface.
DirectMemoryRegion: Interface for a direct memory region allocated by provider.
DirectMessageReader: Message reader implementation.
DirectMessageState<T extends DirectMessageStateItem>: Message state.
DirectMessageStateItem: Message state item.
DirectMessageWriter: Message writer implementation.
DiscoCache
DisconnectedSessionInfo: Class marker that say that connection must be interacted.
DiscoveryCustomEvent: Custom event.
DiscoveryCustomMessage: DiscoveryCustomMessage messages are handled by discovery protocol which provides some guarantees around them.
DiscoveryDataBag: Provides interface for `GridComponent` to collect and exchange discovery data both on joining node and on cluster nodes.
DiscoveryDataBag.GridDiscoveryData: Facade interface representing `DiscoveryDataBag` object with discovery data collected in the grid.
DiscoveryDataBag.JoiningNodeDiscoveryData: Facade interface representing `DiscoveryDataBag` object with discovery data from joining node.
DiscoveryDataClusterState: A pojo-object representing current cluster global state.
DiscoveryDataPacket: Carries discovery data in marshalled form and allows convenient way of converting it to and from `DiscoveryDataBag` objects.
DiscoveryEvent: Grid discovery event.
DiscoveryEventListener: Internal listener for discovery events.
DiscoveryLocalJoinData: Information about local join event.
DiscoveryMessageResultsCollector<M,​R>
DiscoveryMessageResultsCollector.NodeMessage<M>
DiscoveryMetricsProvider: Provides metrics to discovery SPI.
DiscoveryNodeValidationProcessor: Node validation.
DiscoveryNotification: Discovery notification object.
DiscoveryServerOnlyCustomMessage: DiscoveryServerOnlyCustomMessage is the special subtype of the DiscoveryCustomMessage message that is delivered only on server nodes of the cluster.
DiscoverySpi: Grid discovery SPI allows to discover remote nodes in grid.
DiscoverySpiCustomMessage: Message to send across ring.
DiscoverySpiDataExchange: Handler for initial data exchange between Ignite nodes.
DiscoverySpiHistorySupport: This annotation is for all implementations of `DiscoverySpi` that support topology snapshots history.
DiscoverySpiListener: Listener for grid node discovery events.
DiscoverySpiMBean: Generic MBean interface to monitor DiscoverySpi subsystem.
DiscoverySpiMutableCustomMessageSupport: This annotation is for all implementations of `DiscoverySpi` that support topology mutable `DiscoverySpiCustomMessage`s.
DiscoverySpiNodeAuthenticator: Node authenticator.
DiscoverySpiOrderSupport: This annotation is for all implementations of `DiscoverySpi` that support proper node ordering.
DiskPageCompression: Disk page compression options.
DistributedBaselineConfiguration: Distributed baseline configuration.
DistributedBooleanProperty: Implementation of `DistributedProperty` for `Boolean`.
DistributedChangeableProperty<T extends Serializable>: Inner interface to maintenance of distributed property.
DistributedCollectionMetadata
DistributedComparableProperty<T extends Comparable<T> & Serializable>: Implementation of `DistributedProperty` for `Comparable`.
DistributedConfigurationLifecycleListener: Lifecycle listener for distributed configuration.
DistributedConfigurationProcessor: Processor of distributed configuration.
DistributedConfigurationUtils: Distributed configuration utilities methods.
DistributedDoubleProperty: Implementation of `DistributedProperty` for `Double`.
DistributedEnumProperty<T extends Enum>: Distributed enum implementation for storing into meta storage.
DistributedIntegerProperty: Implementation of `DistributedProperty` for `Integer`.
DistributedLongProperty: Implementation of `DistributedProperty` for `Long`.
DistributedMetaStorage: API for distributed data storage with the ability to write into it.
DistributedMetaStorageImpl: Implementation of `DistributedMetaStorage` based on `MetaStorage` for persistence and discovery SPI for communication.
DistributedMetastorageLifecycleListener: Listener for `DistributedMetaStorage` lifecycle events.
DistributedMetaStorageListener<T extends Serializable>: Listener for distributed metastorage data updates.
DistributedProcess<I extends Serializable,​R extends Serializable>: Distributed process is a cluster-wide process that accumulates single nodes results to finish itself.
DistributedProcess.DistributedProcessType: Defines distributed processes.
DistributedProperty<T extends Serializable>: Public interface of distributed property usage.
DistributedPropertyDispatcher: Dispatcher of distributed properties.
DistributedSqlConfiguration: Common distributed SQL configuration.
DistributedThinClientConfiguration: Thin client distributed configuration.
DistributedTracingConfiguration: The wrapper of `HashMap<TracingConfigurationCoordinates, TracingConfigurationParameters>` for the distributed metastorage binding.
DistributedTransactionConfiguration: Distributed transaction configuration.
DistributePropertyListener<T>: Listener of distributed property change event.
DmsDataWriterWorker
DoubleGauge: Implementation based on primitive supplier.
DoubleIndexKey
DoubleInlineIndexKeyType: Inline index key implementation for inlining `Double` values.
DoubleMetric: Interface for the metrics that holds double primitive.
DoubleMetricImpl: Double metric.
Dump: This class provides the ability to work with saved cache dump.
Dump.DumpedPartitionIterator: Closeable dump iterator.
DumpConsumer: Consumer of a cache dump.
DumpConsumerKernalContextAware: Dump consumer that needs to use `GridKernalContext` must implement this interface.
DumpEntry: Single cache entry from dump.
DumpEntryChangeListener: Copy on write listener that handles changes of entries during dump.
DumpEntrySerializer: Serialization logic for dump.
DumpReader: Dump Reader application.
DumpReaderConfiguration: Configuration class of `DumpReader`.
DumpSupported<T extends PageLockDump>: Interface for all page lock tracker entries which support dumping.
DuplicateTypeIdException: The exception indicates a duplicate type ID was encountered.
DurableBackgroundCleanupIndexTreeTask: Deprecated. Use `DurableBackgroundCleanupIndexTreeTaskV2`.
DurableBackgroundCleanupIndexTreeTaskV2: Task for background cleaning of index trees.
DurableBackgroundCleanupIndexTreeTaskV2.InlineIndexTreeFactory: Factory for creating index trees.
DurableBackgroundCleanupIndexTreeTaskV2.NoopRowHandlerFactory: A do-nothing `InlineIndexRowHandlerFactory` implementation.
DurableBackgroundTask<R>: Durable task that should be used to do long operations (e.g. index deletion) in background.
DurableBackgroundTaskResult<R>: Result of executing a durable background task.
DurableBackgroundTasksProcessor: Processor that is responsible for durable background tasks that are executed on local node.
DurableBackgroundTaskState<R>: Class for storing the current state of a durable background task.
DurableBackgroundTaskState.State: Enumeration of the current state of the task.
DynamicCacheChangeBatch: Cache change batch.
DynamicCacheChangeFailureMessage: This class represents discovery message that is used to provide information about dynamic cache start failure.
DynamicCacheChangeRequest: Cache start/stop request.
DynamicCacheDescriptor: Cache start descriptor.
EarliestCheckpointMapSnapshot: Earliest checkpoint map snapshot.
EncryptedFileIO: Implementation of `FileIO` that supports encryption(decryption) of pages written(readed) to(from) file.
EncryptedFileIOFactory: Factory to produce `EncryptedFileIO`.
EncryptedRecord: Encrypted record from WAL.
EncryptionCacheGroupArg
EncryptionCacheKeyIdsCommand
EncryptionCacheKeyProvider: Provider for cache's encryption keys.
EncryptionChangeCacheKeyCommand
EncryptionChangeMasterKeyCommand
EncryptionChangeMasterKeyCommandArg
EncryptionCommand: Encryption features command.
EncryptionConfiguration: Encryption configuration.
EncryptionGetMasterKeyNameCommand
EncryptionKeyIdsTask: Get current encryption key IDs of the cache group.
EncryptionKeyIdsTask.EncryptionKeyIdsResult
EncryptionMXBean: Deprecated. Use managements API beans, instead.
EncryptionMXBeanImpl: Encryption features MBean.
EncryptionReencryptionRateLimitCommand
EncryptionReencryptionRateLimitCommandArg
EncryptionReencryptionStatusCommand
EncryptionReencryptionStatusCommandArg
EncryptionResumeReencryptionCommand
EncryptionSpi: SPI provides encryption features for an Ignite.
EncryptionSuspendReencryptionCommand
EncryptionUtil: Encryption utililty class.
EntryByKeyEvaluationPredicate<K,​V>: Predicate evaluates to true for given value.
EntryGetResult
EntryGetWithTtlResult
EntryProcessorResourceInjectorProxy<K,​V,​T>: Entry processor wrapper injecting Ignite resources into target processor before execution.
EnumDescription: Annotation clarifies enum values in command arguments if required.
EqualsClusterNodeIdPredicate<T extends ClusterNode>: Creates grid node predicate evaluating on the given node ID.
EqualsUuidPredicate: UUID equals predicate.
Event: Grid events are used for notification about what happens within the grid.
EventAdapter: Base adapter for the events.
EventListenerDemultiplexer: Routes events to listeners, specified in the client configuration.
EventStorageSpi: This SPI provides local node events storage.
EventType: Contains event type constants.
EvictableEntry<K,​V>: Evictable cache entry passed into `EvictionPolicy`.
EvictionContext: Additional context for partition eviction process.
EvictionFilter<K,​V>: Eviction filter to specify which entries should not be evicted.
EvictionPolicy<K,​V>: Pluggable cache eviction policy.
ExchangeActions: Cache change requests to execute when receive `DynamicCacheChangeBatch` event.
ExchangeActions.CacheActionData
ExchangeActions.CacheGroupActionData
ExchangeContext
ExchangeDiscoveryEvents: Discovery events processed in single exchange (contain multiple events if exchanges for multiple discovery events are merged into single exchange).
ExchangeLatchManager: Class is responsible to create and manage instances of distributed latches `Latch`.
ExchangeRecord: Partition map exchange WAL record.
ExchangeRecord.Type
ExecutorAwareMessage: Message with specified custom executor must be processed in the appropriate thread pool.
ExecutorConfiguration: Custom thread pool configuration for compute tasks.
ExponentialBackoffTimeoutStrategy: Strategy which incorporates retriable network operation, handling of totalTimeout logic.
Extension: Marker interface for extensions.
ExtensionRegistry: Context that allows to register extensions.
F: Defines `alias` for `GridFunc` by extending it.
F0: Internal utility class that contains not peer-deployable predicates for use in internal logic.
FailoverContext: This interface defines a set of operations available to failover SPI one a given failed job.
FailoverSpi: Failover SPI provides developer with ability to supply custom logic for handling failed execution of a grid job.
FailureContext: Failure context contains information about failure type and exception if applicable.
FailureHandler: Provides facility to handle failures by custom user implementations, which can be configured by `IgniteConfiguration.setFailureHandler(FailureHandler)` method.
FailureHandlingMxBean: MBean that controls critical failure handling.
FailureHandlingMxBeanImpl
FailureProcessor: General failure processing API
FailureType: Types of failures.
FairFifoPageEvictionTracker: On-heap FIFO page eviction tracker.
FastCrc: This CRC calculation implementation workf much faster then `PureJavaCrc32`
FastSizeDeque<E>: `Deque` decorator that uses `LongAdder` for faster size computation.
FeatureChecker: Class extracted for fields from GridUnsafe to be absolutely independent with current and future static block initialization effects.
FetchActiveTxOwnerTraceClosure: Closure that is computed on near node to get the stack trace of active transaction owner thread.
FetchNearXidVersionTask: Retrieves unique transaction identifier (nearXid) from UUID/GridCacheVersion of xid/nearXid.
FieldsQueryCursor<T>: SQL query result cursor.
FifoEvictionPolicy<K,​V>: Eviction policy based on `First In First Out (FIFO)` algorithm and supports batch eviction.
FifoEvictionPolicyFactory<K,​V>: Factory class for `FifoEvictionPolicy`.
FifoEvictionPolicyMBean: MBean for `FIFO` eviction policy.
FifoQueueCollisionSpi: This class provides implementation for Collision SPI based on FIFO queue.
FifoQueueCollisionSpiMBean: Management bean that provides access to the FIFO queue collision SPI configuration.
FileDescriptor: WAL file descriptor.
FileDownloader: Part of direct node to node file downloading
FileHandleManager: Manager of `FileWriteHandle`.
FileHandleManagerFactory: Factory of `FileHandleManager`.
FileHandleManagerImpl: Manager for `FileWriteHandleImpl`.
FileInput: File input, backed by byte buffer file input.
FileInput.Crc32CheckingFileInput: Checking of CRC32.
FileIO: Interface to perform file I/O operations.
FileIODecorator: Decorator class for File I/O
FileIOFactory: `FileIO` factory definition.
FileLockHolder: Abstract file lock holder.
FilePageStore: FilePageStore is a PageStore implementation that uses regular files to store pages.
FilePageStoreManager: File page store manager.
FilePageStoreManager.LongOperationAsyncExecutor: Synchronization wrapper for long operations that should be executed asynchronously and operations that can not be executed in parallel with long operation.
FilePageStoreV2
FilePerformanceStatisticsReader: Walker over the performance statistics file.
FilePerformanceStatisticsWriter: Performance statistics writer based on logging to a file.
FileSystemUtils: Native file system API.
FileUploader: Part of direct node to node file downloading
FileVersionCheckingFactory: Checks version in files if it's present on the disk, creates store with latest version otherwise.
FileWriteAheadLogManager: File WAL manager.
FileWriteAheadLogManager.ReadFileHandle
FileWriteHandle: File write handle.
FilteredRecord: Special type of WAL record.
FilteredWalIterator: Decorator of `WALIterator` which allow filter record by `WALPointer` and `WALRecord`.
Filtrable: Annotation to mark view row attribute for a `SystemViewRowAttributeWalker` as filtrable.
FiltrableSystemView<R>: System view with filtering capabilities.
FiltrableSystemViewAdapter<R,​D>: System view which supports attribute filtering.
FindAndDeleteGarbageInPersistenceClosure: Class contains logic of finding data of already destroyed caches in running cache groups.
FindAndDeleteGarbageInPersistenceJobResult: Result of job work which is sent between nodes.
FindAndDeleteGarbageInPersistenceTask: Compute task which are part of 'find and delete garbage' functionality.
FindAndDeleteGarbageInPersistenceTaskResult: Result of running `FindAndDeleteGarbageInPersistenceTask` which would contain result from all participating nodes.
FinishPreloadingTask: A task for finishing preloading future in exchange worker thread.
FirstConnectionPolicy: First connection policy.
FixCountRecord: Fix elements count record.
FixLeftmostChildRecord: Fix leftmost child.
FixRemoveId: Fix remove ID record.
FlatCollectionWrapper<T>: Wrapper which iterable over the elements of the inner collections.
FlatIterator<T>: Iterator over the elements of given iterators.
FloatIndexKey
FloatInlineIndexKeyType: Inline index key implementation for inlining `Float` values.
ForceRebalanceExchangeTask
FreeList<T extends Storable>
FsyncFileHandleManagerImpl: Implementation of `FileWriteHandle` for FSYNC mode.
FullMessage<R extends Serializable>: Full process message.
FullPageId: Compound object used to address a page in the global page space.
FullPageIdTable
FullyConnectedComponentSearcher: Class to find (possibly) largest fully-connected component (also can be called as complete subgraph) in graph.
FutureTask<T>
G: Defines `alias` for `Ignition` by extending it.
GatewayProtectedCacheProxy<K,​V>: Cache proxy wrapper with gateway lock provided operations and possibility to change cache operation context.
GatherPartitionStatistics: Implementation of statistic collector.
GatherStatisticCancelException
GenerateEncryptionKeyRequest: Generate encryption key request.
GenerateEncryptionKeyResponse: Generate encryption key response.
GetMasterKeyNameTask: The task for getting the master key name.
GPC<T>: Defines internal `typedef` for `GridPlainCallable`.
GPR: Defines internal `typedef` for `GridPlainRunnable`.
GridAbsClosure: Defines a convenient absolute, i.e.
GridAbsClosureX: Convenient abs-closure subclass that allows for thrown grid exception.
GridAbsPredicate: Defines absolute (no-arg) predicate construct.
GridAbsPredicateX: Convenient predicate subclass that allows for thrown grid exception.
GridAbstractCommunicationClient: Implements basic lifecycle for communication clients.
GridAffinityAssignment: Deprecated.
GridAffinityAssignmentCache: Affinity cached function.
GridAffinityAssignmentV2: Cached affinity calculations V2.
GridAffinityFunctionContextImpl: Cache affinity function context implementation.
GridAffinityProcessor: Data affinity processor.
GridAnnotationsCache: Caches class loaders for classes.
GridArgumentCheck: This class encapsulates argument check (null and range) for public facing APIs.
GridArrays: Utility methods to work with arrays.
GridAtomicCacheQueueImpl<T>: `IgniteQueue` implementation using atomic cache.
GridAtomicInitializer<T>: Executes initialization operation once.
GridAtomicInteger: Extended version of `AtomicInteger`.
GridAtomicLong: Extended version of `AtomicLong`.
GridBaselineCommandHandler
GridBaselineCommandResponse: Result for baseline command.
GridBinaryMarshaller: Binary objects marshaller.
GridBoundedConcurrentLinkedHashMap<K,​V>: Concurrent map with an upper bound.
GridBoundedConcurrentLinkedHashSet<E>: Concurrent set with an upper bound.
GridBoundedConcurrentOrderedMap<K,​V>: Concurrent ordered map that automatically manages its maximum size.
GridBoundedConcurrentOrderedSet<E>: Concurrent ordered set that automatically manages its maximum size.
GridBoundedLinkedHashMap<K,​V>: Generic map with an upper bound.
GridBoundedLinkedHashSet<E>: Hash table and linked list implementation of the `Set` interface, with predictable iteration order.
GridBoundedPriorityQueue<E>: Bounded variant of `PriorityQueue`.
GridBufferedParser: This class implements stream parser based on `GridNioServerBuffer`.
GridBusyLock: Synchronization aid to track "busy" state of a subsystem that owns it.
GridByteArrayInputStream: This class defines input stream backed by byte array.
GridByteArrayList: Re-sizable array implementation of the byte list (eliminating auto-boxing of primitive byte type).
GridByteArrayOutputStream: This class defines output stream backed by byte array.
GridCacheAdapter<K,​V>: Adapter for different cache implementations.
GridCacheAdapter.AtomicReadRepairEntryProcessor<K,​V>
GridCacheAdapter.BulkOperation
GridCacheAdapter.CacheExpiryPolicy
GridCacheAdapter.FutureHolder: Holder for last async operation future.
GridCacheAdapter.InvokeAllTimeStatClosure<T>
GridCacheAdapter.PeekModes
GridCacheAdapter.TopologyVersionAwareJob: Delayed callable class.
GridCacheAdapter.UpdateGetAllTimeStatClosure<T>
GridCacheAdapter.UpdateGetAndRemoveTimeStatClosure<T>
GridCacheAdapter.UpdateGetTimeStatClosure<T>
GridCacheAdapter.UpdatePutAllConflictTimeStatClosure<T>
GridCacheAdapter.UpdatePutAllTimeStatClosure<T>
GridCacheAdapter.UpdatePutAndGetTimeStatClosure<T>
GridCacheAdapter.UpdatePutTimeStatClosure<T>
GridCacheAdapter.UpdateRemoveAllConflictTimeStatClosure<T>
GridCacheAdapter.UpdateRemoveAllTimeStatClosure<T>
GridCacheAdapter.UpdateRemoveTimeStatClosure
GridCacheAdapter.UpdateTimeStatClosure<T>
GridCacheAffinityImpl<K,​V>: Affinity interface implementation.
GridCacheAffinityManager: Cache affinity manager.
GridCacheAffinityProxy<K,​V>: Affinity interface implementation.
GridCacheAnnotationHelper<A extends Annotation>: Utility class for getting annotated values from classes.
GridCacheAtomicFuture<R>: Update future for atomic cache.
GridCacheAtomicLongEx: Atomic managed by cache (`'Ex'` stands for external).
GridCacheAtomicLongImpl: Cache atomic long implementation.
GridCacheAtomicLongValue: Atomic long value.
GridCacheAtomicReferenceEx<T>: Atomic reference managed by cache (`'Ex'` stands for external).
GridCacheAtomicReferenceImpl<T>: Cache atomic reference implementation.
GridCacheAtomicReferenceValue<T>: Atomic reference value.
GridCacheAtomicSequenceEx: Sequence managed by cache (`'Ex'` stands for external.
GridCacheAtomicSequenceImpl: Cache sequence implementation.
GridCacheAtomicSequenceValue: Sequence value.
GridCacheAtomicStampedEx<T,​S>: Atomic stamped managed by cache (`'Ex'` stands for external).
GridCacheAtomicStampedImpl<T,​S>: Cache atomic stamped implementation.
GridCacheAtomicStampedValue<T,​S>: Atomic stamped value.
GridCacheAtomicVersionComparator: Atomic cache version comparator.
GridCacheAttributes: Cache attributes.
GridCacheAttributesEntryExtras: Extras where attributes are set.
GridCacheAttributesMvccEntryExtras: Extras where attributes and MVCC are set.
GridCacheAttributesMvccObsoleteEntryExtras: Extras where attributes, MVCC and obsolete version are set.
GridCacheAttributesMvccObsoleteTtlEntryExtras: Extras where attributes, MVCC, obsolete version and TTL are set.
GridCacheAttributesMvccTtlEntryExtras: Extras where attributes, MVCC and TTL are set.
GridCacheAttributesObsoleteEntryExtras: Extras where attributes and obsolete version are set.
GridCacheAttributesObsoleteTtlEntryExtras: Extras where attributes, obsolete version and TTL are set.
GridCacheAttributesTtlEntryExtras: Extras where attributes and TTL are set.
GridCacheClearAllRunnable<K,​V>: Base runnable for `IgniteInternalCache.clearLocally(boolean, boolean, boolean)` routine.
GridCacheCommandHandler: Command handler for API requests.
GridCacheCompoundFuture<T,​R>
GridCacheCompoundIdentityFuture<T>
GridCacheConcurrentMap: Concurrent cache map.
GridCacheConcurrentMap.CacheMapHolder
GridCacheConcurrentMapImpl: Implementation of concurrent cache map.
GridCacheContext<K,​V>: Cache context.
GridCacheContextInfo<K,​V>: Cache context information.
GridCacheCountDownLatchEx: Grid cache count down latch (`'Ex'` stands for external).
GridCacheCountDownLatchImpl: Cache count down latch implementation.
GridCacheCountDownLatchValue: Count down latch value.
GridCacheDatabaseSharedManager
GridCacheDatabaseSharedManager.NodeFileLockHolder: Node file lock holder.
GridCacheDefaultAffinityKeyMapper: Default key affinity mapper.
GridCacheDeployable: Deployable cache message.
GridCacheDeploymentManager<K,​V>: Deployment manager for cache.
GridCacheDistributedFieldsQueryFuture: Distributed fields query future.
GridCacheDistributedQueryFuture<K,​V,​R>: Distributed query future.
GridCacheDistributedQueryManager<K,​V>: Distributed query manager (for cache in REPLICATED / PARTITIONED cache mode).
GridCacheDrExpirationInfo: Cache DR info used as argument in PUT cache internal interfaces with expiration info added.
GridCacheDrInfo: Cache DR info used as argument in PUT cache internal interfaces.
GridCacheDrManager: Replication manager class which processes all replication events.
GridCacheEntryEx: Internal API for cache entry (`'Ex'` stands for extended).
GridCacheEntryExtras: Cache extras.
GridCacheEntryExtrasAdapter: Cache extras adapter.
GridCacheEntryInfo: Entry information that gets passed over wire.
GridCacheEntryRedeployException: Thrown when an entry could not be redeployed.
GridCacheEntryRemovedException: Thrown when an operation is performed on removed entry.
GridCacheEventManager: Cache event manager.
GridCacheEvictionManager
GridCacheExplicitLockSpan: Collection of near local locks acquired by a thread on one topology version.
GridCacheFilterFailedException: Thrown when an operation is performed on removed entry.
GridCacheFuture<R>: This interface should be implemented by all distributed futures.
GridCacheFutureAdapter<R>
GridCacheGateway<K,​V>: Cache gateway.
GridCacheGroupIdMessage: Message related to particular cache group.
GridCacheIdMessage: Message related to particular cache.
GridCacheIndexUpdateException: Exception indicating that index update failed during cache entry update.
GridCacheInternal: Marker interface using in cache implementations.
GridCacheInternalKey: Key is used for caching data structure.
GridCacheInternalKeyImpl: Key is used for caching cache data structures.
GridCacheIoManager: Cache communication manager.
GridCacheIterator<K,​V,​T>: Cache-backed iterator.
GridCacheLazyPlainVersionedEntry<K,​V>: Lazy plain versioned entry.
GridCacheLocalConcurrentMap: GridCacheConcurrentMap implementation for local and near caches.
GridCacheLocalFieldsQueryFuture: Local fields query future.
GridCacheLocalQueryFuture<K,​V,​R>: Local query future.
GridCacheLockCallback: Lock and Unlock callbacks.
GridCacheLockEx: Grid cache reentrant lock (`'Ex'` stands for external).
GridCacheLockImpl: Cache reentrant lock implementation based on AbstractQueuedSynchronizer.
GridCacheLockState: Grid cache reentrant lock state.
GridCacheLockTimeoutException: Used to internally indicate that lock acquisition has timed out.
GridCacheManager<K,​V>: Interface for cache managers.
GridCacheManagerAdapter<K,​V>: Convenience adapter for cache managers.
GridCacheMapEntry: Adapter for cache entry.
GridCacheMapEntryFactory: Factory for cache entries.
GridCacheMappedVersion: Interface mostly for Near to DHT version mapping.
GridCacheMessage: Parent of all cache messages.
GridCacheMultiTxFuture<K,​V>: Future which waits for completion of one or more transactions.
GridCacheMvcc: Replicated lock based on MVCC paradigm.
GridCacheMvccCandidate: Lock candidate.
GridCacheMvccEntryExtras: Extras where MVCC is set.
GridCacheMvccManager: Manages lock order within a thread.
GridCacheMvccObsoleteEntryExtras: Extras where MVCC and obsolete version are set.
GridCacheMvccObsoleteTtlEntryExtras: Extras where MVCC, obsolete version and TTL are set.
GridCacheMvccTtlEntryExtras: Extras where MVCC and TTL are set.
GridCacheObsoleteEntryExtras: Extras where obsolete version is set.
GridCacheObsoleteTtlEntryExtras: Extras where obsolete version and TTL are set.
GridCacheOffheapManager: Used when persistence enabled.
GridCacheOffheapManager.GridCacheDataStore
GridCacheOperation: Cache value operations.
GridCachePartitionedConcurrentMap: An implementation of GridCacheConcurrentMap that will delegate all method calls to corresponding local partition.
GridCachePartitionExchangeManager<K,​V>: Partition exchange manager.
GridCachePlainVersionedEntry<K,​V>: Plain versioned entry.
GridCachePluginContext<C extends CachePluginConfiguration>: Cache plugin context.
GridCachePreloader: Cache preloader that is responsible for loading cache entries either from remote nodes (for distributed cache) or anywhere else at cache startup.
GridCachePreloaderAdapter: Adapter for preloading which always assumes that preloading finished.
GridCacheProcessor: The main responsibility of this processor is orchestrating of starting, stopping caches and everything related to that activity like validation of cache configuration, restoring configuration from persistence, etc.
GridCacheProxyImpl<K,​V>: Cache proxy.
GridCacheQueryBean: Query execution bean.
GridCacheQueryDetailMetricsAdapter: Adapter for `QueryDetailMetrics`.
GridCacheQueryDetailMetricsKey: Immutable query metrics key used to group metrics.
GridCacheQueryErrorFuture<T>: Error future.
GridCacheQueryFutureAdapter<K,​V,​R>: Query future adapter.
GridCacheQueryManager<K,​V>: Query and index manager.
GridCacheQueryManager.CacheSqlIndexMetadata: Cache metadata index.
GridCacheQueryManager.CacheSqlMetadata: Cache metadata.
GridCacheQueryManager.QueryResult<K,​V>
GridCacheQueryMarshallable: Message which needs to be marshalled and unmarshalled before sending or processing it.
GridCacheQueryMetadataAware: Metadata-aware interface.
GridCacheQueryMetricsAdapter: Adapter for `QueryMetrics`.
GridCacheQueryMetricsAdapter.QueryMetricsSnapshot: Query metrics snapshot.
GridCacheQueryRequest: Query request.
GridCacheQueryResponse: Page of cache query response.
GridCacheQueryResponseEntry<K,​V>: Deprecated. Should be removed in Apache Ignite 3.0.
GridCacheQuerySqlMetadataV2: Cache metadata with not null field.
GridCacheQueryType: Defines different cache query types.
GridCacheQueueAdapter<T>: Common code for `IgniteQueue` implementation.
GridCacheQueueAdapter.AddProcessor
GridCacheQueueAdapter.ClearProcessor
GridCacheQueueAdapter.PollProcessor
GridCacheQueueAdapter.RemoveProcessor
GridCacheQueueHeader: Queue header.
GridCacheQueueHeaderKey: Queue header key.
GridCacheQueueProxy<T>: Cache queue proxy.
GridCacheRawVersionedEntry<K,​V>: Raw versioned entry.
GridCacheRemovable: Provides callback for marking object as removed.
GridCacheRestMetrics: Grid cache metrics for rest.
GridCacheRestResponse: Adds affinity node ID to cache responses.
GridCacheReturn: Return value for cases where both, value and success flag need to be returned.
GridCacheReturnCompletableWrapper: Provides initialized GridCacheReturn.
GridCacheSemaphoreEx: Grid cache semaphore (`'Ex'` stands for external).
GridCacheSemaphoreImpl: Cache semaphore implementation based on AbstractQueuedSynchronizer.
GridCacheSemaphoreState: Grid cache semaphore state.
GridCacheSetHeader: Cache set header.
GridCacheSetHeaderKey: Set header key.
GridCacheSetImpl<T>: Cache set implementation.
GridCacheSetItemKey: Set item key.
GridCacheSetProxy<T>: Cache set proxy.
GridCacheSharedContext<K,​V>: Shared context.
GridCacheSharedContext.Builder: Builder for `GridCacheSharedContext`.
GridCacheSharedManager<K,​V>: Cache manager shared across all caches.
GridCacheSharedManagerAdapter<K,​V>: Convenience adapter for cache managers.
GridCacheSharedTtlCleanupManager: Periodically removes expired entities from caches with `CacheConfiguration.isEagerTtl()` flag set.
GridCacheSqlIndexMetadata: Ignite index descriptor.
GridCacheSqlMetadata: Metadata for Ignite cache.
GridCacheSqlQuery: Query.
GridCacheStoreManagerAdapter: Store manager.
GridCacheTtlEntryExtras: Extras where TTL and expire time are set.
GridCacheTtlManager: Eagerly removes expired entries from cache when `CacheConfiguration.isEagerTtl()` flag is set.
GridCacheTtlUpdateRequest
GridCacheTxRecoveryFuture: Future verifying that all remote transactions related to transaction were prepared or committed.
GridCacheTxRecoveryRequest: Message sent to check that transactions related to transaction were prepared on remote node.
GridCacheTxRecoveryResponse: Transactions recovery check response.
GridCacheUpdateAtomicResult: Cache entry atomic update result.
GridCacheUpdateAtomicResult.UpdateOutcome
GridCacheUpdateTxResult: Cache entry transactional update result.
GridCacheUtilityKey<K extends GridCacheUtilityKey>: Key for system utility cache.
GridCacheUtils: Cache utility methods.
GridCacheUtils.BackupPostProcessingClosure
GridCacheValueCollection<K,​V>: Value collection based on provided entries with all remove operations backed by underlying cache.
GridCacheVersion: Grid unique version.
GridCacheVersionable: Classes that are based on version may choose to implement this interface.
GridCacheVersionAware: Interface implemented by classes that holds version related information.
GridCacheVersionConflictContext<K,​V>: Conflict context implementation.
GridCacheVersionedEntry<K,​V>: Cache entry along with version information.
GridCacheVersionedEntryEx<K,​V>: Extended versioned entry.
GridCacheVersionedFuture<T>: Distributed future aware of lock version.
GridCacheVersionEx: Extended cache version which also has additional DR version.
GridCacheVersionManager: Makes sure that cache lock order values come in proper sequence.
GridCacheWriteBehindStore<K,​V>: Internal wrapper for a `CacheStore` that enables write-behind logic.
GridChangeClusterStateCommandHandler
GridChangeGlobalStateMessageResponse
GridChangeStateCommandHandler
GridCheckpointManager: This class defines a checkpoint manager.
GridCheckpointRequest: This class defines checkpoint request.
GridCircularBuffer<T>: This class implements a circular buffer for efficient data exchange.
GridClassLoaderCache: Caches class loaders for classes.
GridClient: Ignite Java client API.
GridClientAbstractMessage: This class provides implementation for commit message fields and cannot be used directly.
GridClientAuthenticationException: Exception that represents client authentication failure.
GridClientAuthenticationRequest: Client authentication request.
GridClientBalancerAdapter: Base class for balancers.
GridClientBeforeNodeStart: Ignite Java client API for communicate with node before it start.
GridClientBinaryMetaData: Binary meta data sent from client.
GridClientByteUtils: Primitive to byte array and backward conversions.
GridClientCacheBean: Cache bean.
GridClientCacheFlag: Cache projection flags that specify projection behaviour.
GridClientCacheMode: Cache type on remote node.
GridClientCacheRequest: Generic cache request.
GridClientCacheRequest.GridCacheOperation: Available cache operations.
GridClientClosedException: This exception is thrown whenever an attempt is made to use a closed client.
GridClientClusterNameRequest
GridClientClusterState: Interface for managing state of grid cluster and obtaining information about it: ID and tag.
GridClientClusterStateImpl
GridClientClusterStateRequest: Deprecated. Use `GridClientClusterStateRequestV2`
GridClientClusterStateRequestV2: Enhanced version of `GridClientClusterStateRequest`.
GridClientCompute: A compute projection of grid client.
GridClientConfiguration: Java client configuration.
GridClientConnection: Facade for all possible network communications between client and server.
GridClientConnectionManager: Common interface for client connection managers.
GridClientConnectionManagerAdapter: Cached connections manager.
GridClientConnectionManagerOsImpl: Open source version of connection manager.
GridClientConnectionResetException: This exception is thrown when ongoing packet should be sent, but network connection is broken.
GridClientConsistentHash<N>: Controls key to node affinity using consistent hash algorithm.
GridClientData: A data projection of grid client.
GridClientDataAffinity: Determines which node should be connected when operation on a key is requested.
GridClientDataConfiguration: Java client data configuration.
GridClientDataImpl: Data projection that serves one cache instance and handles communication errors.
GridClientDataMetrics: Cache metrics used to obtain statistics on cache itself or any of its entries.
GridClientDataMetricsAdapter: Adapter for cache metrics.
GridClientDisconnectedException: This exception is thrown when client has no Grid topology and (probably temporary) can't obtain it.
GridClientException: Client exception is a common super class of all client exceptions.
GridClientFactory: Client factory opens and closes clients.
GridClientFuture<R>: Future for asynchronous operations.
GridClientFutureAdapter<R>: Future adapter.
GridClientFutureCallback<R,​S>: Future callback will be notified, when listened future finishes (both succeed or failed).
GridClientFutureListener<R>: Listener interface for `GridClientFuture`.
GridClientFutureTimeoutException: Client future timeout exception is thrown whenever any client waiting is timed out.
GridClientHandshakeException: This exception is thrown when a client handshake has failed.
GridClientHandshakeRequest: A client handshake request, containing version info and a marshaller ID.
GridClientHandshakeResponse: A client handshake response, containing result code.
GridClientImpl: Client implementation.
GridClientJdkMarshaller: Simple marshaller that utilize JDK serialization features.
GridClientLoadBalancer: Interface that defines a selection logic of a server node for a particular operation.
GridClientMarshaller: Marshaller for binary protocol messages.
GridClientMessage: Interface for all client messages.
GridClientNioTcpConnection: This class performs request to grid over TCP protocol.
GridClientNode: Descriptor of remote grid node.
GridClientNodeBean: Node bean.
GridClientNodeImpl: Client node implementation.
GridClientNodeImpl.Builder: Builder for instances of this class.
GridClientNodeMetrics: Node metrics for remote grid node.
GridClientNodeMetricsAdapter: Node metrics adapter.
GridClientNodeMetricsBean: Node metrics bean.
GridClientNodeStateBeforeStart: Interface for managing state of a node before it starts and getting information about it.
GridClientNodeStateBeforeStartImpl: Implementation `GridClientNodeStateBeforeStart`.
GridClientNodeStateBeforeStartRequest: Request to manage and obtain information about node before its start.
GridClientOptimizedMarshaller: Wrapper, that adapts `OptimizedMarshaller` to `GridClientMarshaller` interface.
GridClientPacketType: Type of message being parsed.
GridClientPartitionAffinity: Affinity function for partitioned cache.
GridClientPartitionAffinity.HashIdResolver: This resolver is used to provide alternate hash ID, other than node ID.
GridClientPartitionTopology: Partition topology for node which does not have any local partitions.
GridClientPingPacket: Fictive ping packet.
GridClientPredicate<E1>: Defines predicate construct.
GridClientProtocol: Protocol that will be used when client connections are created.
GridClientRandomBalancer: Simple balancer that relies on random node selection from a given collection.
GridClientResponse: Bean representing client operation result.
GridClientRoundRobinBalancer: Simple balancer that implements round-robin balancing.
GridClientStateRequest: Deprecated. Use `GridClientClusterStateRequest` instead.
GridClientStripedLock: This is an utility class for 'splitting' locking of some `int`- or `long`-keyed resources.
GridClientTaskRequest: `Task` command request.
GridClientTaskResultBean: Task result.
GridClientThreadFactory: Delegating thread factory which forces all spawned thread to be daemons.
GridClientTopology: Client topology cache.
GridClientTopologyListener: Listener interface for notifying on nodes joining or leaving remote grid.
GridClientTopologyRequest: `Topology` command request.
GridClientUtils: Java client utils.
GridClientWarmUpRequest
GridClientZipOptimizedMarshaller: Wrapper, that adapts `OptimizedMarshaller` to `GridClientMarshaller` interface.
GridCloseableIterator<T>: Defines "rich" closeable iterator interface that is also acts like lambda function and iterable.
GridCloseableIteratorAdapter<T>: Convenient adapter for closeable iterator.
GridCloseableIteratorAdapterEx<T>: Adapter for closeable iterator that can be safely closed concurrently.
GridClosure3<E1,​E2,​E3,​R>: Defines generic `for-each` type of closure.
GridClosure3X<E1,​E2,​E3,​R>: Convenient closure subclass that allows for thrown grid exception.
GridClosureCallMode: Distribution modes for one or more closures executed via `Grid.call(...)` methods.
GridClosureException: This exception provides closures with facility to throw exceptions.
GridClosureProcessor
GridClosureProcessor.C1<T,​R>
GridClosureProcessor.C1MLA<T,​R>
GridClosureProcessor.C2<R>
GridClosureProcessor.C2MLA<R>
GridClosureProcessor.C4
GridClosureProcessor.C4MLA
GridClusterNameCommandHandler
GridClusterStateProcessor
GridCodegenConverter: Annotates fields that required custom reading / writing.
GridCodegenConverter.Default: Used as the default value for converter type
GridCollections: Provides locked wrappers around given maps and collections.
GridCollisionJobContextAdapter: Adapter for `CollisionJobContext`.
GridCollisionManager: This class defines a collision manager.
GridCommunicationClient
GridComponent: Interface for all main internal Ignite components (managers and processors).
GridComponent.DiscoveryDataExchangeType: Unique component type for discovery data exchange.
GridCompoundFuture<T,​R>: Future composed of multiple inner futures.
GridCompoundIdentityFuture<T>: Compound future with reducer which accepts and produces results of the same type.
GridCompoundReadRepairFuture: Compound future that represents the result of the external fixes for some keys.
GridConcurrentFactory: Concurrent map factory.
GridConcurrentHashSet<E>: Wrapper around concurrent map.
GridConcurrentHashSet<E>: Concurrent set implementation.
GridConcurrentLinkedHashSet<E>: Concurrent linked set implementation.
GridConcurrentMultiPairQueue<K,​V>: Concurrent queue that wraps collection of `Pair<K, V[]>` The only garantee `GridConcurrentMultiPairQueue.next(org.apache.ignite.internal.util.GridConcurrentMultiPairQueue.Result<K, V>)` provided is sequentially emptify values per key array.
GridConcurrentMultiPairQueue.Result<K,​V>: State holder.
GridConcurrentPhantomHashSet<E>: Concurrent phantom hash set implementation.
GridConcurrentSkipListSet<E>: This class provided the same logic as `ConcurrentSkipListSet`.
GridConcurrentWeakHashSet<E>: Concurrent weak hash set implementation.
GridConfigurationFinder: Finds configuration files located in `IGNITE_HOME` folder and its subfolders.
GridConnectionBytesVerifyFilter: Verifies that first bytes received in accepted (incoming) NIO session are equal to `IgniteUtils.IGNITE_HEADER`.
GridConnectionIdleClosedException: This exception is thrown if client was closed by idle checker thread.
GridConsistentHash<N>: Controls key to node affinity using consistent hash algorithm.
GridContinuousBatch: Continuous routine batch.
GridContinuousBatchAdapter: Continuous routine batch adapter.
GridContinuousHandler: Continuous routine handler.
GridContinuousHandler.RegisterStatus: Listener registration status.
GridContinuousMessage: Continuous processor message.
GridContinuousProcessor: Processor for continuous routines.
GridContinuousProcessor.LocalRoutineInfo: Local routine info.
GridContinuousProcessor.RemoteRoutineInfo: Remote routine info.
GridContinuousProcessor.RoutineInfo: Routine interface info.
GridContinuousQueryBatch: Continuous routine batch adapter.
GridCountDownCallback: Allows to execute callback when a set of operations will be completed.
GridCursor<T>: Simple cursor abstraction.
GridCursorIteratorWrapper<V>: Wrap `Iterator` and adapt it to `GridCursor`.
GridDataInput: Extended data input.
GridDataOutput: Extended data output.
GridDebug: Utility class for debugging.
GridDebug.Item: Debug info queue item.
GridDeferredAckMessageSender<T>
GridDelimitedParser: This class implements stream parser based on `GridNioDelimitedBuffer`.
GridDeployment: Represents single class deployment.
GridDeploymentInfo: Deployment info.
GridDeploymentInfoBean: Deployment info bean.
GridDeploymentManager: Deployment manager.
GridDeploymentMetadata: Deployment metadata.
GridDeploymentPerLoaderStore: Deployment storage for `DeploymentMode.PRIVATE` and `DeploymentMode.ISOLATED` modes.
GridDeploymentPerVersionStore: Deployment storage for `DeploymentMode.SHARED` and `DeploymentMode.CONTINUOUS` modes.
GridDeploymentRequest: Deployment request.
GridDeploymentResponse: Grid deployment response containing requested resource bytes.
GridDeploymentStore: Interface for all deployment stores.
GridDhtAffinityAssignmentRequest: Affinity assignment request.
GridDhtAffinityAssignmentResponse: Affinity assignment response.
GridDhtAssignmentFetchFuture: Future that fetches affinity assignment from remote cache nodes.
GridDhtAtomicAbstractUpdateFuture: DHT atomic cache backup update future.
GridDhtAtomicAbstractUpdateRequest
GridDhtAtomicCache<K,​V>: Non-transactional partitioned cache.
GridDhtAtomicDeferredUpdateResponse: Deferred dht atomic update response.
GridDhtAtomicNearResponse: Message sent from DHT nodes to near node in FULL_SYNC mode.
GridDhtAtomicSingleUpdateRequest
GridDhtAtomicUpdateRequest: Lite dht cache backup update request.
GridDhtAtomicUpdateResponse: DHT atomic cache backup update response.
GridDhtCache<K,​V>: DHT cache.
GridDhtCacheAdapter<K,​V>: DHT cache adapter.
GridDhtCacheEntry: Replicated cache entry.
GridDhtCacheEntry.ReaderId: Reader ID.
GridDhtColocatedCache<K,​V>: Colocated cache.
GridDhtColocatedLockFuture: Colocated cache lock future.
GridDhtDetachedCacheEntry: Detached cache entry.
GridDhtEmbeddedFuture<A,​B>: Embedded DHT future.
GridDhtFinishedFuture<T>: Finished DHT future.
GridDhtForceKeysFuture<K,​V>: Force keys request future.
GridDhtForceKeysRequest: Force keys request.
GridDhtForceKeysResponse: Force keys response.
GridDhtFuture<T>: Keys to retry.
GridDhtGetFuture<K,​V>
GridDhtGetSingleFuture<K,​V>
GridDhtInvalidPartitionException: Exception thrown whenever entry is created for invalid partition.
GridDhtLocalPartition: Key partition.
GridDhtLockFuture: Cache lock future.
GridDhtLockRequest: DHT lock request.
GridDhtLockResponse: DHT cache lock response.
GridDhtPartitionDemander: Thread pool for requesting partitions from other nodes and populating local cache.
GridDhtPartitionDemander.RebalanceFuture: The future is created for each topology version if some partitions should present by affinity and completed when all partitions are transferred.
GridDhtPartitionDemandLegacyMessage: Partition demand request.
GridDhtPartitionDemandMessage: Partition demand request.
GridDhtPartitionExchangeId: Exchange ID.
GridDhtPartitionFullMap: Full partition map from all nodes.
GridDhtPartitionMap: Partition map from single node.
GridDhtPartitionsAbstractMessage: Request for single partition info.
GridDhtPartitionsExchangeFuture: Future for exchanging partition maps.
GridDhtPartitionsExchangeFuture.ExchangeType
GridDhtPartitionsFullMessage: Information about partitions of all nodes in topology.
GridDhtPartitionsReservation: Reservation mechanism for multiple partitions allowing to do a reservation in one operation.
GridDhtPartitionsSingleMessage: Information about partitions of a single node.
GridDhtPartitionsSingleRequest: Request for single partition info.
GridDhtPartitionsStateValidator: Class to validate partitions update counters and cache sizes during exchange process.
GridDhtPartitionState: Partition states.
GridDhtPartitionSupplier: Class for supplying partitions to demanding nodes.
GridDhtPartitionSupplyMessage: Partition supply message.
GridDhtPartitionSupplyMessageV2: Supply message with supplier error transfer support.
GridDhtPartitionTopology: Distributed Hash Table (DHT) partition topology.
GridDhtPartitionTopologyImpl: Partition topology.
GridDhtPartitionTopologyImpl.PartitionFactory: Partition factory used for (re-)creating partitions during their lifecycle.
GridDhtPreloader: DHT cache preloader.
GridDhtPreloaderAssignments: Partition to node assignments.
GridDhtTopologyFuture: Future that implements a barrier after which dht topology is safe to use.
GridDhtTopologyFutureAdapter
GridDhtTopologyFutureAdapter.CacheGroupValidation: Cache group validation result.
GridDhtTransactionalCacheAdapter<K,​V>: Base class for transactional DHT caches.
GridDhtTxFinishFuture<K,​V>
GridDhtTxFinishRequest: Near transaction finish request.
GridDhtTxFinishResponse: DHT transaction finish response.
GridDhtTxLocal: Replicated user transaction.
GridDhtTxLocalAdapter: Replicated user transaction.
GridDhtTxMapping: DHT transaction mapping.
GridDhtTxOnePhaseCommitAckRequest: One Phase Commit Near transaction ack request.
GridDhtTxPrepareFuture
GridDhtTxPrepareRequest: DHT prepare request.
GridDhtTxPrepareResponse: DHT transaction prepare response.
GridDhtTxRemote: Transaction created by system implicitly on remote nodes.
GridDhtUnlockRequest: DHT cache unlock request.
GridDhtUnreservedPartitionException: Exception that is thrown when a partition reservation failed.
GridDirectCollection: Annotates iterable fields.
GridDirectMap: Annotates map fields.
GridDirectParser: Parser for direct messages.
GridDirectTransient: Annotates transient fields.
GridDisconnectListener: Node disconnect listener interface.
GridDiscoveryManager: Discovery SPI manager.
GridDiscoveryTopologySnapshot: Topology snapshot managed by discovery manager.
GridDistributedBaseMessage: Base for all messages in replicated cache.
GridDistributedCacheAdapter<K,​V>: Distributed cache implementation.
GridDistributedCacheAdapter.GlobalRemoveAllJob<K,​V>: Internal job which performs remove all primary key mappings operation on a cache with the given name.
GridDistributedCacheEntry: Entry for distributed (replicated/partitioned) cache.
GridDistributedLockCancelledException: Exception thrown whenever an attempt is made to acquire a cancelled lock.
GridDistributedLockRequest: Lock request message.
GridDistributedLockResponse: Lock response message.
GridDistributedTxFinishRequest: Transaction completion message.
GridDistributedTxFinishResponse: Transaction finish response.
GridDistributedTxMapping: Transaction node mapping.
GridDistributedTxPrepareRequest: Transaction prepare request for optimistic and eventually consistent transactions.
GridDistributedTxPrepareResponse: Response to prepare request.
GridDistributedTxRemoteAdapter: Transaction created by system implicitly on remote nodes.
GridDistributedUnlockRequest: Lock request message.
GridDrType: Data center replication type.
GridEmbeddedFuture<A,​B>: Future which waits for embedded future to complete and then asynchronously executes provided closure with embedded future result.
GridEmptyCloseableIterator<T>: Empty closeable iterator.
GridEmptyIterator<T>: Empty iterator.
GridEncryptionManager: Manages cache keys and `EncryptionSpi` instances.
GridEncryptionManager.EmptyResult
GridEncryptionManager.KeyChangeFuture: Key change future.
GridEncryptionManager.NodeEncryptionKeys
GridEventStorageManager: Grid event storage SPI manager.
GridEventStorageMessage: Event storage message.
GridExecutorService: An `ExecutorService` that executes each submitted task in grid through `Ignite` instance, normally configured using `Ignite.executorService()` method.
GridFailoverContextImpl: GridFailoverContext implementation.
GridFailoverManager: Grid failover spi manager.
GridFilenameUtils: General filename and filepath manipulation utilities.
GridFileUtils: General files manipulation utilities.
GridFilteredClosableIterator<T>
GridFilteredIterator<T>: Filtered iterator.
GridFinishedFuture<T>: Future that is completed at creation time.
GridFixedSizeInputStream: Input stream wrapper which allows to read exactly expected number of bytes.
GridFunc: Contains factory and utility methods for `closures`, `predicates`, and `tuples`.
GridFutureAdapter<R>: Future adapter.
GridHandleTable: Lightweight identity hash table which maps objects to integer handles, assigned in ascending order.
GridInClosure3<E1,​E2,​E3>: Defines a convenient `side-effect only` closure, i.e. the closure that has `void` return type.
GridInClosure3X<E1,​E2,​E3>: Convenient in-closure subclass that allows for thrown grid exception.
GridIndexingManager: Manages cache indexing.
GridInternal: Indicates that annotated task should always be loaded with local deployment, ignoring grid source node configuration.
GridInternalException: When log debug mode is disabled this exception should be logged in short form - without stack trace.
GridInternalSubscriptionProcessor: Processor enables grid components to register listeners for events generated by other components on local node.
GridInternalWrapper<T>: Internal wrapper interface for custom resource injection logic.
GridIntIterator: Iterator over integer primitives.
GridIntList: Minimal list API to work with primitive ints.
GridIoManager: This class represents the internal grid communication (input and output) manager which is placed as a layer of indirection between the `IgniteKernal` and `CommunicationSpi`.
GridIoMessage: Wrapper for all grid messages.
GridIoMessageFactory: Message factory implementation.
GridIoPolicy: This enumeration defines different types of communication message processing by the communication manager.
GridIoSecurityAwareMessage
GridIoUserMessage: User message wrapper.
GridIterable<T>: Defines "rich" iterable interface that is also acts as lambda function and iterator.
GridIterableAdapter<T>: Convenient adapter for "rich" iterable interface.
GridIterableAdapter.IteratorWrapper<T>
GridIterator<T>: Defines "rich" iterator interface that is also acts like lambda function and iterable.
GridIteratorAdapter<T>: Convenient adapter for "rich" iterator interface.
GridJavaProcess: Wrapper class around the `Process` suited to run any Java class as separate java process.
GridJobCancelRequest: Job cancellation request.
GridJobContextImpl: Remote job context implementation.
GridJobExecuteRequest: Job execution request.
GridJobExecuteResponse: Job execution response.
GridJobMetrics: Deprecated. Check the `ReadOnlyMetricRegistry` with "name=compute.jobs" instead.
GridJobMetricsProcessor: Deprecated. Check the `ReadOnlyMetricRegistry` with "name=compute.jobs" instead.
GridJobMetricsSnapshot: Deprecated. Check the `ReadOnlyMetricRegistry` with "name=compute.jobs" instead.
GridJobProcessor: Responsible for all grid job execution and communication.
GridJobResultImpl: Class provides implementation for job result.
GridJobSessionImpl: Job session implementation.
GridJobSiblingImpl: This class provides implementation for job sibling.
GridJobSiblingsRequest: Job siblings request.
GridJobSiblingsResponse: Job siblings response.
GridJobWorker: Job worker.
GridKernalContext
GridKernalContextImpl: Implementation of kernal context.

GridKernalGateway

This interface guards access to implementations of public methods that access kernal functionality from the following main API interfaces: `ClusterGroup` Note that this kernal gateway should not be used to guard against method from the following non-rich interfaces since their implementations are already managed by their respective implementing classes: `Ignite` `ClusterNode` Kernal gateway is also responsible for notifying various futures about the change in kernal state so that issued futures could properly interrupt themselves when kernal becomes unavailable while future is held externally by the user.

GridKernalGatewayImpl
GridKernalState: Kernal life cycle states.
GridKeyLock: This is an utility class for 'splitting' locking of some resources.
GridLeanIdentitySet<T>
GridLeanMap<K,​V>: Lean map implementation that keeps up to five entries in its fields.
GridLeanSet<E>: Lean set implementation.
GridListSet<V>: Implementation of `Set` based on internal list rather than hash table.
GridLoadBalancerAdapter: This adapter allows for graceful exception when load balancer gets marshalled.
GridLoadBalancerManager: Load balancing manager.
GridLocalConfigManager: Responsible for restoring local cache configurations (both from static configuration and persistence).
GridLocalEventListener: Listener for asynchronous local node grid events.
GridLogCommandHandler: Handler for `GridRestCommand.LOG` command.
GridLoggerProxy
GridLogThrottle: Grid log throttle.
GridLongList: Minimal list API to work with primitive longs.
GridManager: This interface defines life-cycle for kernal manager.
GridManagerAdapter<T extends IgniteSpi>: Convenience adapter for grid managers.
GridMapEntry<K,​V>: Simple `Map.Entry` implementation.
GridMarshallerMappingProcessor: Processor responsible for managing custom `DiscoveryCustomMessage` events for exchanging marshalling mappings between nodes in grid.
GridMemcachedMessage: Memcached protocol request.
GridMessageCollection<M extends Message>: Collection of messages.
GridMessageListener: Listener for messages received from remote nodes.
GridMessageListenHandler: Continuous handler for message subscription.
GridMetadataAwareAdapter: Convenient adapter for working with metadata.
GridMetadataAwareAdapter.EntryKey: Enum stored predefined keys.
GridMetricManager: This manager should provide `ReadOnlyMetricManager` for each configured `MetricExporterSpi`.
GridMultiCollectionWrapper<E>: Wrapper around several collection, don't allow adding new elements.
GridMutableLong: A mutable long for use in collections.
GridMutex: Serializable mutex.
GridNearAtomicAbstractSingleUpdateRequest
GridNearAtomicAbstractUpdateFuture: Base for near atomic update futures.
GridNearAtomicAbstractUpdateRequest
GridNearAtomicCache<K,​V>: Near cache for atomic cache.
GridNearAtomicCheckUpdateRequest
GridNearAtomicFullUpdateRequest: Lite DHT cache update request sent from near node to primary node.
GridNearAtomicSingleUpdateFilterRequest
GridNearAtomicSingleUpdateFuture: DHT atomic cache near update future.
GridNearAtomicSingleUpdateInvokeRequest
GridNearAtomicSingleUpdateRequest
GridNearAtomicUpdateFuture: DHT atomic cache near update future.
GridNearAtomicUpdateResponse: DHT atomic cache near update response.
GridNearCacheAdapter<K,​V>: Common logic for near caches (smaller local cache that stores most recently or most frequently accessed data).
GridNearCacheClearAllRunnable<K,​V>: Runnable for `IgniteInternalCache.clearLocally(boolean, boolean, boolean)` routine for near cache.
GridNearCacheEntry: Near cache entry.
GridNearGetFuture<K,​V>
GridNearGetRequest: Get request.
GridNearGetResponse: Get response.
GridNearLockFuture: Cache lock future.
GridNearLockMapping: Key-to node mapping.
GridNearLockRequest: Near cache lock request to primary node.
GridNearLockResponse: Near cache lock response.
GridNearOptimisticSerializableTxPrepareFuture
GridNearOptimisticTxPrepareFuture
GridNearOptimisticTxPrepareFutureAdapter
GridNearOptimisticTxPrepareFutureAdapter.KeyLockFuture: Keys lock future.
GridNearPessimisticTxPrepareFuture
GridNearReadRepairAbstractFuture
GridNearReadRepairAbstractFuture.ByteArrayWrapper
GridNearReadRepairAbstractFuture.IgniteConsistencyCheckFailedException
GridNearReadRepairAbstractFuture.IgniteConsistencyRepairFailedException
GridNearReadRepairCheckOnlyFuture: Checks data consistency.
GridNearReadRepairFuture: Checks data consistency.
GridNearSingleGetRequest
GridNearSingleGetResponse
GridNearTransactionalCache<K,​V>: Near cache for transactional cache.
GridNearTxFastFinishFuture
GridNearTxFinishFuture<K,​V>
GridNearTxFinishRequest: Near transaction finish request.
GridNearTxFinishResponse: Reply for synchronous phase 2.
GridNearTxLocal: Replicated user transaction.
GridNearTxPrepareFutureAdapter: Common code for tx prepare in optimistic and pessimistic modes.
GridNearTxPrepareRequest: Near transaction prepare request to primary node.
GridNearTxPrepareResponse: Near cache prepare response.
GridNearTxRemote: Transaction created by system implicitly on remote nodes.
GridNearUnlockRequest: Near cache unlock request.
GridNioAsyncNotifyFilter: Enables multithreaded notification of session opened, message received and session closed events.
GridNioBackPressureControl: Utility class that allows to ignore back-pressure control for threads that are processing messages.
GridNioClientConnectionMultiplexer: Client connection multiplexer based on `GridNioServer`.
GridNioClientParser: Client message parser.
GridNioCodecFilter: Filter that transforms byte buffers to user-defined objects and vice-versa with specified `GridNioParser`.
GridNioDelimitedBuffer: Buffer with message delimiter support.
GridNioEmbeddedFuture<R>: Future that delegates to some other future.
GridNioException: Nio specific exception.
GridNioFilter: This interface defines the general element in transformation chain between the nio server and application.
GridNioFilterAdapter: Class that defines the piece for application-to-network and vice-versa data conversions (protocol transformations, encryption, etc.)
GridNioFilterChain<T>: Filter chain implementation for nio server filters.
GridNioFinishedFuture<R>: Future that represents already completed result.
GridNioFuture<R>: NIO future.
GridNioFutureImpl<R>: Default future implementation.
GridNioMessageReaderFactory: Message reader factory.
GridNioMessageTracker: Message tracker.
GridNioMessageWriterFactory: Message writer factory.
GridNioParser: This interface declares a basic contract on message parsing and encoding to the underlying network layer.
GridNioRecoveryDescriptor: Recovery information for single node.
GridNioServer<T>: TCP NIO server.
GridNioServer.Builder<T>: Constructs a new instance of `GridNioServer`.
GridNioServerBuffer: NIO server buffer.
GridNioServerListener<T>: Listener passed in to the `GridNioServer` that will be notified on client events.
GridNioServerListenerAdapter<T>: Server listener adapter providing empty methods implementation for rarely used methods.
GridNioServerWrapper: Deprecated. Should be removed.
GridNioSession: This interface represents established or closed connection between nio server and remote client.
GridNioSessionImpl
GridNioSessionMetaKey: Meta keys for `GridNioSession`.
GridNioSslFilter: Implementation of SSL filter using `SSLEngine`
GridNioTracerFilter: Filter that inject and extract tracing span from/to process.
GridNodePredicate: Convenient node predicate as a separate class.
GridNoImplicitInjection: Disables injection.
GridNoStorageCacheMap: Empty cache map that will never store any entries.
GridNotIdleException: This exception defines not idle cluster state, when idle state expected.
GridOffHeapEvent: Off-heap event types.
GridOffHeapEventListener: Off-heap event listener.
GridOffHeapEvictListener: Callback for whenever entries get evicted from off-heap store.
GridOffHeapMap: Off-heap map.
GridOffHeapMapFactory: Factory for off-heap maps.
GridOffHeapOutOfMemoryException: Thrown when memory could not be allocated.
GridOffHeapPartitionedMap: Off-heap map.
GridOffHeapProcessor: Manages offheap memory caches.
GridOsCacheDrManager: No-op implementation for `GridCacheDrManager`.
GridOsSegmentationProcessor: No-op implementation for `GridSegmentationProcessor`.
GridPartitionedGetFuture<K,​V>: Colocated get future.
GridPartitionedSingleGetFuture
GridPartitionStateMap: Grid partition state map.
GridPeerDeployAware: Represents any class that needs to maintain or carry on peer deployment information.
GridPeerDeployAwareAdapter: Adapter for common interfaces in closures, reducers and predicates.
GridPeerDeployAwareTaskAdapter<T,​R>: Peer deployment aware task adapter.
GridPerformanceSuggestions: Grid performance suggestions.
GridPlainAbsClosure: Plain closure that does not accept any arguments, returns nothing and do not implement peer deploy aware.
GridPlainCallable<T>: Callable instance that should never be deployed or injected.
GridPlainClosure<T,​R>: Closure that takes argument, returns result and do not implement `GridPeerDeployAware`.
GridPlainClosure2<T1,​T2,​R>: Closure taking 2 arguments.
GridPlainInClosure<T>: Plain closure that takes one input argument and does not implement `GridPeerDeployAware`.
GridPlainOutClosure<R>: Closure that takes no arguments, returns result and does not implement `GridPeerDeployAware`.
GridPlainRunnable: Runnable instance that should never be deployed or injected.
GridPluginComponent
GridPluginContext
GridPortListener: Listener for port change events.
GridPortProcessor: Registers and deregisters all ports used by SPI and Manager.
GridPortRecord: This class defines record about port use.
GridPredicate3<E1,​E2,​E3>: Defines predicate construct.
GridPredicate3X<E1,​E2,​E3>: Convenient predicate subclass that allows for thrown grid exception.
GridProbeCommandHandler: Handler for `GridRestCommand.PROBE`.
GridProcessor: Interface for all processors.
GridProcessorAdapter: Advanced parent adapter for all processor.
GridProtocolHandler: Custom stream protocol handler implementation.
GridProxyListener: Interception listener is notified about method apply.
GridQueryCacheObjectsIterator: Deserializes binary objects if needed.
GridQueryCancel: Holds query cancel state.
GridQueryCancelRequest: Cancel map part of query request.
GridQueryFailResponse: Error message.
GridQueryFieldMetadata: Query field descriptor.
GridQueryFieldsResult: Field query result.
GridQueryFieldsResultAdapter: Convenience adapter for `GridQueryFieldsResult`.
GridQueryFinishedInfo: Info about finished query.
GridQueryIndexDescriptor: Describes an index to be created for a certain type.
GridQueryIndexing: Abstraction for internal indexing implementation.
GridQueryKillRequest: Query kill request.
GridQueryKillResponse: Query kill response.
GridQueryNextPageRequest: Request to fetch next page.
GridQueryNextPageResponse: Next page response.
GridQueryProcessor: Indexing processor.
GridQueryProperty: Description and access method for query entity field.
GridQueryRowCacheCleaner: Row cache cleaner is used by page memory manager to remove updated / evicted links from rows cache.
GridQueryRowDescriptor: Row descriptor.
GridQueryRowDescriptorImpl: Row descriptor.
GridQueryStartedInfo: Info about new started query.
GridQueryTypeDescriptor: Value descriptor which allows to extract fields from value object of given type.
GridQueue<E>: Queue which supports addition at tail and removing at head.
GridQueue.Node<E>: Node for internal linked list.
GridRandom: Random to be used from a single thread.
GridRedisAppendCommandHandler: Redis APPEND command handler.
GridRedisCommand: Supported Redis-specific commands.
GridRedisCommandHandler: Command handler.
GridRedisConnectionCommandHandler: Redis connection handler.
GridRedisDbSizeCommandHandler: Redis DBSIZE command handler.
GridRedisDelCommandHandler: Redis DEL command handler.
GridRedisExistsCommandHandler: Redis EXISTS command handler.
GridRedisExpireCommandHandler: Redis EXPIRE/PEXPIRE command handler.
GridRedisFlushCommandHandler: Redis FLUSHDB/FLUSHALL command handler.
GridRedisGenericException: Generic Redis protocol exception.
GridRedisGetCommandHandler: Redis GET command handler.
GridRedisGetRangeCommandHandler: Redis SETRANGE command handler.
GridRedisGetSetCommandHandler: Redis GETSET command handler.
GridRedisIncrDecrCommandHandler: Redis INCR/DECR command handler.
GridRedisMessage: Message to communicate with Redis client.
GridRedisMGetCommandHandler: Redis MGET command handler.
GridRedisMSetCommandHandler: Redis MSET command handler.
GridRedisNioListener: Listener for Redis protocol requests.
GridRedisProtocolParser: Parser to decode/encode Redis protocol (RESP) requests.
GridRedisRestCommandHandler: Redis command handler done via REST.
GridRedisSetCommandHandler: Redis SET command handler.
GridRedisSetRangeCommandHandler: Redis SETRANGE command handler.
GridRedisStrlenCommandHandler: Redis STRLEN command handler.
GridRedisTypeException: Exception on operation on the wrong data type.
GridReflectionCache: Reflection field and method cache for classes.
GridReservable: Reservations support.
GridResourceIoc: Resource container contains caches for classes used for injection.
GridResourceIoc.AnnotationSet
GridResourceJobContextInjector: Simple injector which wraps ComputeJobContext resource object.
GridResourceLoggerInjector
GridResourceProcessor: Processor for all Ignite and task/job resources.
GridResourceProxiedIgniteInjector: Ignite instance injector.
GridResourceServiceInjector: Grid service injector.
GridRestAuthenticationRequest: Grid authentication request.
GridRestBaselineRequest: Grid command topology request.
GridRestCacheRequest: Cache command request descriptor.
GridRestChangeStateRequest
GridRestClusterNameRequest: Grid command request of cluster name.
GridRestClusterStateRequest
GridRestCommand: Supported commands.
GridRestCommandHandler: Command handler.
GridRestCommandHandlerAdapter: Abstract command handler.
GridRestLogRequest: Grid command request of log file.
GridRestNodeStateBeforeStartRequest: Request to manage and obtain information about node before its start.
GridRestProcessor: Rest processor implementation.
GridRestProtocol: REST protocol.
GridRestProtocolAdapter: Abstract protocol adapter.
GridRestProtocolHandler: Command protocol handler.
GridRestRequest: Grid command request.
GridRestResponse: JSON response.
GridRestTaskRequest: Grid task command request.
GridRestTopologyRequest: Grid command topology request.
GridRestWarmUpRequest: Grid warm-up request.
GridReversedLinesFileReader: Reads lines in a file reversely (similar to a BufferedReader, but starting at the last line).
GridRouterClientImpl: A `GridClient` router implementation.
GridRouterCommandLineStartup: Loader class for router.
GridRouterFactory: This factory is responsible for router lifecycle management.
GridRouterRequest: Container for routed message information.
GridRouterResponse
GridRunningQueryInfo: Query descriptor.

GridSecurityProcessor

This interface is responsible for: Node authentication; Thin client authentication; Providing configuration info whether global node authentication is enabled; Keeping and propagating all authenticated security subjects; Providing configuration info whether security mode is enabled at all; Handling expired sessions; Providing configuration info whether sandbox is enabled; Keeping and propagating authenticated security subject for thin clients; Keeping and propagating authenticated security contexts for nodes and thin clients; Authorizing specific operations (cache put, task execute, so on) when session security context is set.

GridSegmentationProcessor: Kernal processor responsible for checking network segmentation issues.
GridSelectorNioSessionImpl: Session implementation bound to selector API and socket API.
GridSerializableCollection<E>: Makes `AbstractCollection` as `Serializable` and is useful for making anonymous serializable collections.
GridSerializableIterable<E>: Makes `Iterable` as `Serializable` and is useful for making anonymous serializable iterators.
GridSerializableIterator<E>: Makes `Iterator` as `Serializable` and is useful for making anonymous serializable iterators.
GridSerializableList<E>: Makes `AbstractList` as `Serializable` and is useful for making anonymous serializable lists.
GridSerializableMap<K,​V>: Makes `AbstractMap` as `Serializable` and is useful for making anonymous serializable maps.
GridSerializableSet<E>: Makes `AbstractSet` as `Serializable` and is useful for making anonymous serializable sets.
GridServerUnreachableException: Thrown when none of the servers from configuration can be connected within a timeout.
GridServiceDeploymentCompoundFuture<T extends Serializable>: Service deployment compound future.
GridServiceDeploymentFuture<T extends Serializable>: Service deployment future.
GridServiceMethodNotFoundException: Exception thrown if service is not found.
GridServiceNotFoundException: Exception thrown if service is not found.
GridServiceProxy<T>: Wrapper for making `Service` class proxies.
GridSetQueryPredicate<K,​V>: Predicate for query over `IgniteSet` items.
GridSetWrapper<E>: Set implementation that delegates to map.
GridSnapshotLock<X>: Synchronization primitive allowing concurrent updates and taking consistent snapshots.
GridSpiCloseableIteratorWrapper<T>: Wrapper used to covert `IgniteSpiCloseableIterator` to `GridCloseableIterator`.
GridSpinBusyLock: Synchronization aid to track "busy" state of a subsystem that owns it.
GridSpinReadWriteLock
GridSpiTimeoutObject: Wrapper for `IgniteSpiTimeoutObject`.
GridSpringResourceContext: Interface was introduced to avoid compile-time dependency on spring framework.
GridSslMeta
GridStringBuilder: Optimized string builder with better API.
GridStringBuilderFactory: Per-thread cache of `StringBuilder` instances.
GridStripedLock: This is an utility class for 'splitting' locking of some `int`- or `long`-keyed resources.
GridStripedReadWriteLock: This is an utility class for 'splitting' locking of some `int`- or `long`-keyed resources.
GridStripedSpinBusyLock: Striped spin busy lock.
GridSynchronizedMap<K,​V>: Synchronized map for cache values that is safe to update in-place.
GridSystemViewManager: This manager should provide `ReadOnlySystemViewRegistry` for each configured `SystemViewExporterSpi`.
GridTaskCancelRequest: Request for cancelling tasks.
GridTaskCommandHandler: Command handler for API requests.
GridTaskNameHashKey: Keys for task name hashing.
GridTaskProcessor: This class defines task processor.
GridTaskResultRequest: Task result request.
GridTaskResultResponse: Task result response.
GridTaskSessionImpl: Task session.
GridTaskSessionInternal: Internal task session interface.
GridTaskSessionProcessor
GridTaskSessionRequest: Task session request.
GridTaskWorker<T,​R>: Grid task worker.
GridTcpMemcachedNioListener: Handles memcache requests.
GridTcpNioCommunicationClient: Grid client for NIO server.
GridTcpRestNioListener: Listener for nio server that handles incoming tcp rest packets.
GridTcpRestParser: Parser for extended memcache protocol.
GridTcpRestParser.HeaderData: Header.
GridTcpRestParser.ParserState: Holder for parser state and temporary buffer.
GridTcpRestProtocol: TCP binary protocol implementation.
GridTcpRouter: TCP router interface.
GridTcpRouterConfiguration: This class defines runtime configuration for TCP router.
GridTcpRouterImpl: Wrapper class for router process.
GridTcpRouterMBean: MBean interface for TCP router.
GridTcpRouterNioListenerAdapter: Nio listener for the router.
GridTestPrintStream: Print stream that prints each thread group into a separate buffer.
GridTestPrintStreamFactory: Factory that allow to acquire/release Print Stream for test logging.
GridTimeoutObject: All objects that can timeout should implement this interface.
GridTimeoutObjectAdapter: Default implementation for `GridTimeoutObject`.
GridTimeoutProcessor: Detects timeout events and processes them.
GridTimer: Timer to use mostly for debugging purposes.
GridTimerTask: Utility extension for `TimerTask`.
GridTopic: Communication topic.
GridTopologyCommandHandler: Command handler for API requests.
GridToStringBuilder: Provides auto-generation framework for `toString()` output.
GridToStringExclude: Attach this annotation to a field or a class to indicate that this field or fields of this class should not be included in `toString()` output.
GridToStringInclude: Attach this annotation to a field or a class to indicate that this field or fields of this class should be included in `toString()` output.
GridToStringOrder: Attach this annotation to a field to provide its order in `toString()` output.
GridTracingConfigurationManager: Tracing configuration manager implementation that uses distributed meta storage in order to store tracing configuration.
GridTracingManager: Tracing Manager.
GridTransactionalCacheQueueImpl<T>: `IgniteQueue` implementation using transactional cache.
GridTreePrinter<T>: Abstract tree structure printer.
GridTriple<T>: Simple extension over `GridTuple3` for three objects of the same type.
GridTuple<V>: Convenience class representing mutable tuple of a single value.
GridTuple3<V1,​V2,​V3>: Convenience class representing mutable tuple of three values.
GridTuple4<V1,​V2,​V3,​V4>: Convenience class representing mutable tuple of four values.
GridTuple5<V1,​V2,​V3,​V4,​V5>: Convenience class representing mutable tuple of five values.
GridTuple6<V1,​V2,​V3,​V4,​V5,​V6>: Convenience class representing mutable tuple of six values.
GridUnsafe: Wrapper for `Unsafe` class.
GridUnsafeDataInput: Data input based on `Unsafe` operations.
GridUnsafeDataOutput: Data output based on `Unsafe` operations.
GridUnsafeMap: Off-heap map based on `Unsafe` implementation.
GridUnsafeMemory: Unsafe memory.
GridUnsafePartitionedMap: Off-heap map based on `Unsafe` implementation.
GridUrlConnection: Connection implementation for custom protocol.
GridVersionCommandHandler: Handler for `GridRestCommand.VERSION` and `GridRestCommand.NAME` command.
GridWeakIterator<T>: Weak iterator.
GridWorker: Extension to standard `Runnable` interface.
GridWorkerFuture<T>: Future for locally executed closure that defines cancellation logic.
GridWorkerListener: This interface defines worker listener.
GridWorkerListenerAdapter: Convenience adapter for `GridWorkerListener`.
GridWorkerPool: Pool of runnable workers.
GroupKey: Cache group encryption key with identifier.
GroupKeyEncrypted: Cache group encryption key with identifier.
GroupPartitionId: Pair of cache group ID with partition ID.
H2Dialect: A dialect compatible with the H2 database.
HandshakeException: Internal exception class for proper timeout handling.
HandshakeFailEvent
HandshakeMessage: Handshake message.
HandshakeMessage2: Updated handshake message.
HandshakeStartEvent
HandshakeSuccessEvent
HandshakeTimeoutObject: Callback that is intended to be executed after timeout on handshake.
HandshakeWaitMessage: Message requesting to wait until node's SPI context initialize.
HasEqualIdPredicate<T extends ClusterNode>: `ClusterNode` has equal id predicate.
Hasher: Implement Murmur8_128 hash function for byte arrays.
HasNotEqualIdPredicate<T extends ClusterNode>: `ClusterNode` node has NOT equal id predicate.
HeaderRecord: Header record.
HeapPageMetaInfoStore
HeavyQueriesTracker: Class to track heavy queries (long-running or producing a big result-set).
HeavyQueriesTracker.ResultSetChecker: Holds result-set limit settings for the specified query.
HelpCommand: Marker interface only for backward compatibility with `./control.sh`.
HighPriorityListener: Marker interface for listeners called before 'regular' listeners.
HistogramMetric: Histogram metric calculates counts of measurements that gets into each bounds interval.
HistogramMetricImpl: Histogram metric implementation.
HistoryAffinityAssignment: Interface for historical calculated affinity assignment.
HistoryAffinityAssignmentImpl: Heap-space optimized version of calculated affinity assignment.
HistoryAffinityAssignmentShallowCopy: Shallow copy that contains reference to delegate `HistoryAffinityAssignment`.
HitRateMetric: Accumulates approximate hit rate statistics.
HLL: A probabilistic set of hashed `long` elements.
HLLMetadata: A concrete `IHLLMetadata` implemented as a simple struct.
HLLType: The types of algorithm/data structure that `HLL` can utilize.
HLLUtil: Static functions for computing constants and parameters used in the HLL algorithm.
HostAndPortRange: Represents address along with port range.
HttpIgniteUpdatesChecker: This class is responsible for getting Ignite updates information via HTTP
IdealAffinityAssignment
IdentityClosure: Identity closure.
IdleVerifyDumpResult: Encapsulates result of `VerifyBackupPartitionsDumpTask`.
IdleVerifyDumpTask: Task to verify checksums of backup partitions and return all collected information.
IdleVerifyException: This exception is used to collect exceptions occured in `VerifyBackupPartitionsTaskV2` execution.
IdleVerifyResultV2: Encapsulates result of `VerifyBackupPartitionsTaskV2`.
IdleVerifyTaskV2: Task to verify checksums of backup partitions.
IdleVerifyUtility: Utility class for idle verify command.
IdleVerifyUtility.IdleChecker: Idle checker.
IdleVerifyUtility.VerifyPartitionContext
Ignite: Main entry-point for all Ignite APIs.
IgniteAccessControlException: Exception that represents authentication / authorization failure.
IgniteAsyncCallback: If callback has this annotation then it will be executing in another thread.
IgniteAsyncSupport: Deprecated. since 2.0.
IgniteAsyncSupported: Deprecated. since 2.0.
IgniteAtomicConsistencyViolationException: Atomic consistency violation exception.
IgniteAtomicLong: This interface provides a rich API for working with distributedly cached atomic long value.
IgniteAtomicReference<T>: This interface provides a rich API for working with distributed atomic reference.
IgniteAtomicSequence: This interface provides a rich API for working with distributed atomic sequence.
IgniteAtomicStamped<T,​S>: This interface provides a rich API for working with distributed atomic stamped value.
IgniteAuthenticationException: Exception that represents authentication failure.
IgniteAuthenticationProcessor
IgniteBiClosure<E1,​E2,​R>: Defines generic closure with two parameters.
IgniteBiInClosure<E1,​E2>: Closure with two in-parameters and void return type.
IgniteBinary: Defines binary objects functionality.
IgniteBinaryImpl: `IgniteBinary` implementation.
IgniteBiPredicate<E1,​E2>: Defines a predicate which accepts two parameters and returns `true` or `false`.
IgniteBiTuple<V1,​V2>: Convenience class representing mutable tuple of two values.
IgniteCache<K,​V>: Main entry point for all Data Grid APIs. You can get a named cache by calling `Ignite.cache(String)` method.
IgniteCacheDatabaseSharedManager
IgniteCacheExpiryPolicy: Wrapper for `ExpiryPolicy` used to track information about cache entries whose time to live was modified after access.
IgniteCacheFutureImpl<V>: Implementation of public API future for cache.
IgniteCacheObjectProcessor: Cache objects processor.
IgniteCacheOffheapManager
IgniteCacheOffheapManager.CacheDataStore
IgniteCacheOffheapManager.OffheapInvokeClosure
IgniteCacheOffheapManagerImpl
IgniteCacheOffheapManagerImpl.CacheDataStoreImpl
IgniteCacheOffheapManagerImpl.ExpiredKeyCacheObject: This entry key is used to indicate that an expired entry has already been deleted from PendingEntriesTree and doesn't need to participate in PendingEntriesTree cleanup again.
IgniteCacheProxy<K,​V>: Cache proxy.
IgniteCacheProxyImpl<K,​V>: Cache proxy implementation.
IgniteCacheRestartingException: Exception thrown from ignite cache API if cache is restarting.
IgniteCallable<V>: Grid-aware adapter for `Callable` implementations.
IgniteChangeGlobalStateSupport: Provides callback during activation/deactivation cluster.
IgniteCheckedException: General grid exception.
IgniteClient: Ignite thin client.
IgniteClientDisconnectedCheckedException
IgniteClientDisconnectedException: Exception thrown from Ignite API when client node disconnected from cluster.
IgniteClientException: Client exception.
IgniteClientFuture<T>: Thin client async operations future.
IgniteClientFutureImpl<T>: Ignite thin client future - a wrapper around `CompletableFuture`.
IgniteClosure<E,​R>: Defines generic closure with one parameter.
IgniteClosure2X<E1,​E2,​R>: Convenient closure subclass that allows for thrown grid exception.
IgniteClosureX<E,​R>: Convenient closure subclass that allows for thrown grid exception.
IgniteCluster: Represents whole cluster (all available nodes) and also provides a handle on `IgniteCluster.nodeLocalMap()` which provides map-like functionality linked to current grid node.
IgniteClusterAsyncImpl
IgniteClusterEx
IgniteClusterImpl
IgniteClusterMXBean: Deprecated. Use managements API beans, instead.
IgniteClusterMXBeanImpl: Implementation of `IgniteClusterMXBean` interface.
IgniteClusterNode
IgniteClusterReadOnlyException: This exception is used to indicate that the cluster is in a read-only state
IgniteCodeGeneratingFail: Annotates fields that code generator should not be override.
IgniteCollectors: Custom collectors for `Stream` API.
IgniteCommandRegistry: Ignite command registry containing all commands known by Ignite node.
IgniteComponentType: Component type.
IgniteCompute: Defines compute grid functionality for executing tasks and closures over nodes in the `ClusterGroup`.
IgniteComputeHandler: Represents a general facade that delegates Ignite compute requests to `GridTaskProcessor` and `GridClosureProcessor` internal processors.
IgniteComputeImpl: `IgniteCompute` implementation.
IgniteCondition: This interface provides a rich API for working with condition objects associated with distributed reentrant locks.
IgniteConfiguration: This class defines grid runtime configuration.
IgniteConfigurationIterable: Responsibility of this class it to recursively iterate `IgniteConfiguration` object and expose all properties in form of String pairs.
IgniteConsistencyViolationException: Consistency violation exception.
IgniteCountDownLatch: This interface provides a rich API for working with distributed count down latch.
IgniteDataIntegrityViolationException: Will be thrown if data integrity violation is found
IgniteDataStreamer<K,​V>: Data streamer is responsible for streaming external data into cache.
IgniteDataStreamerTimeoutException: Exception is thrown when timeout of some `IgniteDataStreamer` operations occurs.
IgniteDataTransferObject: Base class for data transfer objects.
IgniteDataTransferObjectInput: Wrapper for object input.
IgniteDataTransferObjectOutput: Wrapper for object output.
IgniteDefragmentation: Defragmentation operation service.
IgniteDefragmentation.CancelResult: Result of the cancellation.
IgniteDefragmentation.CompletedDefragmentationInfo
IgniteDefragmentation.DefragmentationInfo
IgniteDefragmentation.DefragmentationStatus
IgniteDefragmentation.InProgressDefragmentationInfo
IgniteDefragmentation.ScheduleResult: Result of the scheduling.
IgniteDefragmentationImpl: Defragmentation operation service implementation.
IgniteDeploymentCheckedException: Deployment or re-deployment failed.
IgniteDeploymentException: Deployment or re-deployment failed.
IgniteDhtDemandedPartitionsMap: Map of partitions demanded during rebalancing.
IgniteDhtPartitionCountersMap: Partition counters map.
IgniteDhtPartitionCountersMap2: Partition counters map.
IgniteDhtPartitionHistorySuppliersMap
IgniteDhtPartitionsToReloadMap: Partition reload map.
IgniteDiagnosticAware
IgniteDiagnosticInfo
IgniteDiagnosticMessage
IgniteDiagnosticMessage.DiagnosticBaseClosure
IgniteDiagnosticMessage.ExchangeInfoClosure
IgniteDiagnosticMessage.TxEntriesInfoClosure
IgniteDiagnosticMessage.TxInfoClosure
IgniteDiagnosticPrepareContext: Groups diagnostic closures by node/closure type.
IgniteDiscoverySpi
IgniteDiscoverySpiInternalListener: For TESTING only.
IgniteDiscoveryThread: Marker interface for discovery thread on cluster server node.
IgniteDomainCombiner: A `IgniteDomainCombiner` updates ProtectionDomains with passed `Permissions`.
IgniteDrDataStreamerCacheUpdater: Data center replication cache receiver for data streamer.
IgniteEncryption: Defines encryption features.
IgniteEvents: Provides functionality for local and remote event notifications on nodes defined by `IgniteEvents.clusterGroup()`.
IgniteEventsImpl: `IgniteEvents` implementation.
IgniteEx: Extended Grid interface which provides some additional methods required for kernal and Visor.
IgniteException: General grid exception.
IgniteExceptionRegistry: Utility to collect suppressed errors within internal code.
IgniteExceptionRegistry.ExceptionInfo: Detailed info about suppressed error.
IgniteExperimental: This annotation marks API elements (such as interfaces, methods, annotations and whole API packages) as experimental meaning that the API is not finalized yet and may be changed or replaced in future Ignite releases.
IgniteExternalizableExpiryPolicy: Externalizable wrapper for `ExpiryPolicy`.
IgniteFeatures: Defines supported features and check its on other nodes.
IgniteFinishedCacheFutureImpl<V>
IgniteFinishedFutureImpl<V>
IgniteFuture<V>: Future with simplified exception handling, functional programming support and ability to listen for future completion via functional callback.
IgniteFutureCancelledCheckedException: Future computation cannot be retrieved because it was cancelled.
IgniteFutureCancelledException: Future computation cannot be retrieved because it was cancelled.
IgniteFutureImpl<V>: Implementation of public API future.
IgniteFutureTimeoutCheckedException: Future computation completion is timed out.
IgniteFutureTimeoutException: Future computation completion is timed out.
IgniteGlobalStatisticsManager: Global statistics manager.
IgniteHistoricalIterator: Iterator that provides history of updates for a subset of partitions.
IgniteHistoricalIteratorException: Thrown when `IgniteHistoricalIterator` cannot iterate over WAL for some reason.
IgniteIllegalStateException: This exception indicates the ignite access in invalid state.
IgniteInClosure<E>: Closure with one in-parameter and void return type.
IgniteInClosure2X<E1,​E2>: Convenient in-closure subclass that allows for thrown grid exception.
IgniteInClosureX<T>: Convenient in-closure subclass that allows for thrown grid exception.
IgniteInstanceResource: Annotates a field or a setter method for injection of current `Ignite` instance.
IgniteInternalCache<K,​V>: This interface provides a rich API for working with distributed caches.
IgniteInternalFuture<R>: Extension for standard `Future` interface.
IgniteInternalTx: Transaction managed by cache (`'Ex'` stands for external).
IgniteInternalTx.FinalizationStatus
IgniteInterruptedCheckedException: This exception is used to wrap standard `InterruptedException` into `IgniteCheckedException`.
IgniteInterruptedException: This exception is used to wrap standard `InterruptedException` into `IgniteException`.
IgniteIoTestMessage
IgniteIrreparableConsistencyViolationException: Irreparable consistency violation exception.
IgniteJdbcDriver: JDBC driver implementation for In-Memory Data Grid.
IgniteJdbcThinDataSource: JDBC thin DataSource implementation.
IgniteJdbcThinDriver: JDBC driver thin implementation for In-Memory Data Grid.
IgniteKernal: This class represents an implementation of the main Ignite API `Ignite` which is expanded by additional methods of `IgniteEx` for the internal Ignite needs.
IgniteLock: This interface provides a rich API for working with distributed reentrant locks.
IgniteLogger: This interface defines basic logging functionality used throughout the system.
IgniteLoggerEx: Internal extension of `IgniteLogger`.
IgniteLogInfoProvider: Pluggable Ignite component that is responsible for printing custom information during the Ignite lifecycle start phase.
IgniteLogInfoProviderImpl: Default implementation of Ignite information.
IgniteMarshallerClassFilter
IgniteMBeanAware: MBean-aware interface.
IgniteMBeansManager: Class that registers and unregisters MBeans for kernal.
IgniteMessageFactoryImpl: Message factory implementation which is responsible for instantiation of all communication messages.
IgniteMessaging: Provides functionality for topic-based message exchange among nodes defined by `IgniteMessaging.clusterGroup()`.
IgniteMessagingImpl: `IgniteMessaging` implementation.
IgniteMetrics: Allows managing the custom metrics.
IgniteMXBean: This interface defines JMX view on kernal.
IgniteMXBeanImpl: Implementation of `IgniteMXBean`.
IgniteNeedReconnectException: Indicates that node should try reconnect to cluster.
IgniteNodeAttributes: This class defines constants (NOT enums) for internally-used node attributes.
IgniteNodeStartUtils: Util methods for `IgniteCluster.startNodes(..)` methods.
IgniteNodeValidationResult: Result of joining node validation.
IgniteNoopScheduleProcessor: No-op implementation of `IgniteScheduleProcessorAdapter`, throws exception on usage attempt.
IgniteNotPeerDeployable: This annotations should be used to mark any type that should not be peer deployable.
IgniteObjectInputFilter
IgniteOutClosure<T>: Closure that does not take any parameters and returns a value.
IgniteOutClosureX<T>: Convenient out-closure subclass that allows for thrown grid exception.
IgniteOutOfMemoryException
IgnitePageStoreManager
IgnitePair<T>: Simple extension over `IgniteBiTuple` for pair of objects of the same type.
IgnitePeerToPeerClassLoadingException: This exception is thrown in communication-related cases when it is impossible to load class from any peer.
IgnitePlugin: Marker interface for all Ignite plugins.
IgnitePluginProcessor
IgnitePortProtocol: Protocols supported by port processor.
IgnitePredicate<E>: Defines a predicate which accepts a parameter and returns `true` or `false`.
IgnitePredicate2X<E1,​E2>: Convenient predicate subclass that allows for thrown grid exception.
IgnitePredicateX<E1>: Convenient predicate subclass that allows for thrown grid exception.
IgniteProducer<T>: Defines a producer which can throw IgniteCheckedException.
IgniteProductVersion: Represents node version.
IgniteProperties: Ignite properties holder.
IgniteQueryErrorCode: Error codes for query operations.
IgniteQueue<T>: This interface provides a rich API for working with distributed queues based on In-Memory Data Grid.
IgniteRebalanceIterator: Iterator over supplied data for rebalancing.
IgniteRebalanceIteratorImpl: Default iterator for rebalancing.
IgniteReducer<E,​R>: Defines generic reducer that collects multiple values and reduces them into one.
IgniteReducer2<E1,​E2,​R>: Defines generic `for-all` or `reduce` type of closure.
IgniteReducer2X<E1,​E2,​R>: Convenient reducer subclass that allows for thrown grid exception.
IgniteReducer3<E1,​E2,​E3,​R>: Defines generic `for-all` or `reduce` type of closure.
IgniteReducer3X<E1,​E2,​E3,​R>: Convenient reducer subclass that allows for thrown grid exception.
IgniteReducerX<E1,​R>: Convenient reducer subclass that allows for thrown grid exception.
IgniteReflectionFactory<T>: Factory implementation that use reflection to create instance of given class.
IgniteRemoteMapTask<T,​R>: Util task that will execute ComputeTask on a given node.
IgniteRemoteStartSpecification: Host data.
IgniteRestProcessor: REST processor marker interface.
IgniteRunnable: Grid-aware adapter for `Runnable` implementations.
IgniteSandbox: IgniteSandbox executes a user-defined code with restrictions.
IgniteScheduleProcessorAdapter: Schedules cron-based execution of grid tasks and closures.
IgniteScheduler: Provides functionality for scheduling jobs locally using UNIX cron-based syntax.
IgniteSchedulerImpl: `IgniteScheduler` implementation.
IgniteSecurity: Ignite Security Processor.
IgniteSecurityAdapter
IgniteSecurityProcessor: Default `IgniteSecurity` implementation.
IgniteSemaphore: This interface provides a rich API for working with distributed semaphore.
IgniteServiceProcessor: Ignite service processor.
IgniteServices: Defines functionality necessary to deploy distributed services on the grid.
IgniteServicesEx: Extended interface that provides additional internal methods for managing services.
IgniteServicesImpl: `IgniteServices` implementation.
IgniteSet<T>: Set implementation based on on In-Memory Data Grid.
IgniteSingletonIterator<T>: Trivial iterator to return single item.
IgniteSnapshot: This interface provides functionality for creating cluster-wide cache data snapshots.
IgniteSnapshotManager: Internal implementation of snapshot operations over persistence caches.
IgniteSnapshotManager.ClusterSnapshotFuture
IgniteSnapshotManager.SnapshotHandlers: Snapshot operation handlers.
IgniteSnapshotVerifyException: Compound snapshot verification exception from the nodes where the verification process executed.
IgniteSpi: This interface defines life-cycle of SPI implementation.
IgniteSpiAdapter: This class provides convenient adapter for SPI implementations.
IgniteSpiCloseableIterator<T>: Closeable iterator.
IgniteSpiConfiguration: Annotates SPI configuration setters on whether or not it is optional.
IgniteSpiConsistencyChecked: SPIs that have this annotation present will be checked for consistency within grid.
IgniteSpiContext: SPI context provides common functionality for all SPI implementations.
IgniteSpiException: Exception thrown by SPI implementations.
IgniteSpiManagementMBean: This interface defines basic MBean for all SPI implementations.
IgniteSpiMBeanAdapter: This class provides convenient adapter for MBean implementations.
IgniteSpiMultiException: Grid SPI exception which may contain more than one failure.
IgniteSpiMultipleInstancesSupport: Annotates whether or not multiple instances of this SPI can be started in the same VM.
IgniteSpiNoop: Annotates `NO-OP` SPI implementations.
IgniteSpiOperationTimeoutException: Kind of exception that is used when failure detection timeout is enabled for `TcpDiscoverySpi` or `TcpCommunicationSpi`.
IgniteSpiOperationTimeoutHelper: Object that incorporates logic that determines a timeout value for the next network related operation and checks whether a failure detection timeout is reached or not.
IgniteSpiThread: This class provides convenient adapter for threads used by SPIs.
IgniteSpiThreadFactory: This class provides implementation of `ThreadFactory` factory for creating grid SPI threads.
IgniteSpiTimeoutObject: Provides possibility to schedule delayed execution, see `IgniteSpiContext.addTimeoutObject(IgniteSpiTimeoutObject)`.
IgniteSpiVersionCheckException: Grid SPI exception for version check failure.
IgniteSpringHelper: Spring helper which can parse Spring configuration files, interface was introduced to avoid mandatory runtime dependency on Spring framework.
IgniteSQLException: Specific exception bearing information about query processing errors for more detailed errors in JDBC driver.
IgniteSshHelper: SSH processor, interface was introduced to avoid mandatory runtime dependency on SSH library.
IgniteStandardMXBean: Extension of standard Java MBean.
IgniteState: Possible states of `Ignition`.
IgniteStatisticsConfigurationManager: Holds statistic configuration objects at the distributed metastore and match local statistics with target statistic configuration.
IgniteStatisticsDummyStoreImpl: Statistics store implementation to log unexpected calls.
IgniteStatisticsHelper: Utility methods to statistics messages generation.
IgniteStatisticsInMemoryStoreImpl: Sql statistics storage in metastore.
IgniteStatisticsManager: Statistics manager.
IgniteStatisticsManagerImpl: Statistics manager implementation.
IgniteStatisticsPersistenceStoreImpl: Sql statistics storage in metastore.
IgniteStatisticsRepository: Statistics repository implementation.
IgniteStatisticsRepository.VersionedStatistics: Object statistics with topology version to which it is actual for.
IgniteStatisticsStore: Statistics store interface.
IgniteStopwatch: An object that measures elapsed time in nanoseconds.
IgniteStripedThreadPoolExecutor: An `ExecutorService` that executes submitted tasks using pooled grid threads.
IgniteSystemProperties: Contains constants for all system properties and environmental variables in Ignite.
IgniteThread: This class adds some necessary plumbing on top of the `Thread` class.
IgniteThreadFactory: This class provides implementation of `ThreadFactory` factory for creating grid threads.
IgniteThreadPoolExecutor: An `ExecutorService` that executes submitted tasks using pooled grid threads.
IgniteThrowableBiPredicate<T,​U>: Represents a predicate (boolean-valued function) of two arguments.
IgniteThrowableConsumer<E>: Represents an operation that accepts a single input argument and returns no result.
IgniteThrowableFunction<E,​R>: Represents a function that accepts one argument and produces a result.
IgniteThrowableRunner: Represents a throwable runner.
IgniteThrowableSupplier<E>: Represents a supplier of results.
IgniteTicker: A time source; returns a time value representing the number of nanoseconds elapsed since some fixed but arbitrary point in time.
IgniteTooManyOpenFilesException: Custom exception for `SocketException` with Too many open files error message.
IgniteTransactionalConsistencyViolationException: Consistency violation exception.
IgniteTransactions: Transactions facade provides ACID-compliant semantic when working with caches.
IgniteTransactionsEx: Extended interface to work with system transactions.
IgniteTransactionsImpl<K,​V>: Grid transactions implementation.
IgniteTree<L,​T>: Interface for ignite internal tree.
IgniteTree.InvokeClosure<T>
IgniteTree.OperationType
IgniteTxAdapter: Managed transaction adapter.
IgniteTxEntry: Transaction entry.
IgniteTxHandler: Isolated logic to process cache messages.
IgniteTxHeuristicCheckedException: Exception thrown whenever grid transaction enters an unknown state.
IgniteTxImplicitSingleStateImpl
IgniteTxKey: Cache transaction key.
IgniteTxLocalAdapter: Transaction adapter for cache transactions.
IgniteTxLocalEx: Local transaction API.
IgniteTxLocalState
IgniteTxLocalStateAdapter
IgniteTxManager: Cache transaction manager.
IgniteTxMap: Grid cache transaction read or write set.
IgniteTxMappings
IgniteTxMappingsImpl
IgniteTxMappingsSingleImpl
IgniteTxOptimisticCheckedException: Exception thrown whenever grid transactions fail optimistically.
IgniteTxRemoteEx: Local transaction API.
IgniteTxRemoteSingleStateImpl
IgniteTxRemoteState
IgniteTxRemoteStateAdapter
IgniteTxRemoteStateImpl
IgniteTxRollbackCheckedException: Exception thrown whenever grid transactions has been automatically rolled back.
IgniteTxState
IgniteTxStateAware: Marker interface for messages with transient TX state
IgniteTxStateImpl
IgniteTxTimeoutCheckedException: Exception thrown whenever grid transactions time out.
IgniteUtils: Collection of utility methods used throughout the system.
IgniteUtils.InterfaceSupplier: Explicit class for `Supplier<Enumeration<NetworkInterface>>`.
IgniteUuid: This is a faster performing version of `UUID`.
IgniteUuidCache
IgniteVersionUtils: Ignite version utils.
IgniteWalIteratorFactory: Factory for creating iterator over WAL files
IgniteWalIteratorFactory.ConsoleLogger
IgniteWalIteratorFactory.IteratorParametersBuilder: Wal iterator parameter builder.
IgniteWriteAheadLogManager
Ignition: This class defines a factory for the main Ignite API.
IgnitionEx: This class is part of an internal API and can be modified at any time without backward compatibility.
IgnitionListener: Listener for gird state change notifications.
IgnitionMXBean: This interface defines JMX view on `Ignition`.
IgnitionMXBeanAdapter: Management bean that provides access to `Ignition`.
IgnoreIfPeerClassLoadingDisabled: This annotation is for all implementations of `DeploymentSpi` that may be ignored if peer class loading is disabled.
IGridClusterStateProcessor
IHLLMetadata: The metadata and parameters associated with a HLL.
ImmutableIntSet
impl: Documentation annotation for Scala.
InboundConnectionHandler: This class implement NioListener which process handshake stage, and transmit messages to session.
IncompleteCacheObject: Cache object container that accumulates partial binary data unless all of them ready.
IncompleteDeserializationException: Exception which can be used to access a message which failed to be deserialized completely using Java serialization.
IncompleteObject<T>: Incomplete object.
IncrementalSnapshotAwareMessage: Message that holds a transaction message and incremental snapshot ID.
IncrementalSnapshotFinishRecord: This record is written to WAL after incremental snapshot finished on a baseline node.
IncrementalSnapshotMetadata: Incremental snapshot metadata file.
IncrementalSnapshotStartRecord: This record is written to WAL at the moment when incremental snapshot starts on a baseline node.
IncrementalSnapshotVerificationTask
IncrementalSnapshotVerificationTask.HashHolder: Holder for calculated hashes.
Index: Basic interface for Ignite indexes.
IndexBuildStatusHolder: Cache index build status.
IndexBuildStatusHolder.Status: Enumeration of statuses.
IndexBuildStatusStorage: Holder of up-to-date information about cache index building operations (rebuilding indexes, building new indexes).
IndexDefinition: Basic interface for index description required to create or destroy index.
IndexDescriptor: Local database index object.
IndexDescriptorFactory: Factory interface, to create index descriptors.
IndexesRebuildTask: Task that rebuilds indexes.
IndexFactory: Base interface for Ignite index factories.
IndexForceRebuildTask: Task that triggers indexes force rebuild for specified caches or cache groups.
IndexForceRebuildTaskRes: Result of `IndexForceRebuildTask`.
IndexingDefragmentation
IndexingQueryCacheFilter: Indexing query filter for specific cache.
IndexingQueryEngine: Marker interface for Indexing-backed query engine (indexing implementation will be used instead of query engine).
IndexingQueryFilter: Cache entry filter.
IndexingQueryFilterImpl: Indexing query filter.
IndexingSpi: Indexing SPI allows user to index cache content.
IndexIntegrityCheckIssue
IndexKey: Class that represnts a single index key.
IndexKeyDefinition: Defines a signle index key.
IndexKeyFactory: Factory for creating IndexKey objects.
IndexKeyType: List of available types to use as index key.
IndexKeyTypeSettings: List of settings that affects key types of index keys.
IndexListInfoContainer: Container for index info.
IndexListTask: Task that collects indexes information.
IndexName: Represents list of names that fully describes index domain (schema, cache, table, index).
IndexPageType: Enumeration of types of b-tree index pages.
IndexPlainRowImpl: Represents a plain row (not bounded to cache data row) that used to find a place in a tree.
IndexProcessor: Implementation of IndexingSpi that tracks all cache indexes.
IndexQuery<K,​V>: Index queries work over distributed indexes and retrieve cache entries that match the specified criteria.
IndexQueryContext
IndexQueryCriteriaBuilder: Factory of `IndexQueryCriterion` for `IndexQuery`.
IndexQueryCriterion: Basic interface for `IndexQuery` criterion.
IndexQueryDesc: Internal representation of `IndexQuery`.
IndexQueryProcessor: Processor of `IndexQuery`.
IndexQueryReducer<R>: Reducer for `IndexQuery` results.
IndexQueryResult<K,​V>: Represents result of local execution of IndexQuery.
IndexQueryResultMeta: Metadata for IndexQuery response.
IndexRebuildCacheInfo: Information about the cache for which index rebuilding was started.
IndexRebuildCancelToken: Index operation cancellation token.
IndexRebuildFutureStorage: Holder of up-to-date information of rebuild index futures for caches.
IndexRebuildStatusInfoContainer: Container for index rebuild status info.
IndexRebuildStatusTask: Task that collects caches that have index rebuild in progress.
IndexRenameRootPageRecord: Logical record for renaming index root pages.
IndexRow: Represents an index row stored in a tree.
IndexRowCache: H2 row cache.
IndexRowCacheRegistry: Index row cache registry.
IndexRowComparator: Comparator for index rows.
IndexRowComparatorImpl: Provide default logic of rows comparison.
IndexRowImpl: This class represents a row in `SortedSegmentedIndex`.
IndexStorage: Meta store.
IndexStorageImpl: Metadata storage.
IndexStorageImpl.IndexItem
IndexStorageImpl.MetaStoreInnerIO
IndexStorageImpl.MetaStoreLeafIO
IndexValidationIssue
IndexValueCursor<V>: Cursor over index values.
InIndexQueryCriterion: Criterion for IN operator.
InitializationProtector: Class for avoid multiple initialization of specific value from various threads.
InitMessage<I extends Serializable>: Initiate message.
InitNewCoordinatorFuture
InitNewPageRecord: Initializes new page by calling `PageIO.initNewPage(long, long, int, PageMetrics)`.
InlineIndex: Represents an index that inlines some of index keys.
InlineIndexFactory: Factory to create `InlineIndex`.
InlineIndexImpl: Sorted index implementation.
InlineIndexKeyType: Basic interface for inlined index columns.
InlineIndexKeyTypeRegistry: Provide mapping for java types and `IndexKeyType` that supports inlining.
InlineIndexRowHandler: Handles InlineIndexRow.
InlineIndexRowHandlerFactory: Basic interface for factories that provide InlineIndexRowHandler based on index definition and optional arguments.
InlineIndexTree: BPlusTree where nodes stores inlined index keys.
InlineInnerIO: Implementation of `AbstractInlineInnerIO`
InlineIO: Represents common API for inline IOs.
InlineLeafIO: Represents common API for inline IOs.
InlineObjectBytesDetector: This class helps to detect whether tree contains inlined JO type.
InlineRecommender: Write to a log recommendation for inline size.
InlineTreeFilterClosure: Represents filter that allow query only primary partitions.
InnerIO: Inner page for index rows without inline payload.
InnerReplaceRecord<L>: Inner replace on remove.
InsertRecord<L>: Insert into inner or leaf page.
IntegerIndexKey
IntegerInlineIndexKeyType: Inline index key implementation for inlining `Integer` values.
InterruptibleVisorTask: This annotation using for Visor's task which can interrupted by system reason.
IntGauge: Implementation based on primitive supplier.
IntHashMap<V>: The simple map for primitive types base on Robin-hood hashing with backward shift.
IntMap<V>: The map for integer keys.
IntMap.EntryConsumer<V,​E extends Throwable>: The bridge for consuming all entries of the map.
IntMetric: Interface for the metrics that holds int primitive.
IntMetricImpl: Int metric implementation.
IntRWHashMap<V>: Read-write lock wrapper for `IntMap`.
IntSet
IntSumReducer: Reducer that calculates sum of integer elements.
InvalidContext<T extends PageLockDump>: Failure context if any invariant is not satisfied.
InvalidEnvironmentException: Marker interface of invalid environment exception.
IoPool: The interface of IO Messaging Pool Extension.
IORowHandler: Class provide a common logic for storing an index row.
IoStatisticsHolder: Holder of IO statistics.
IoStatisticsHolderCache: Cache statistics holder to gather statistics related to concrete cache.
IoStatisticsHolderIndex: Index statistics holder to gather statistics related to concrete index.
IoStatisticsHolderNoOp: No Operation IO statistics holder.
IoStatisticsHolderQuery: Query Statistics holder to gather statistics related to concrete query.
IoStatisticsQueryHelper: Helper for gathering IO statistics.
IoStatisticsType: Type of statistics.
IOVersions<V extends PageIO>: Registry for IO versions.
IpcClientTcpEndpoint: Loopback IPC endpoint based on socket.
IpcEndpoint: IPC endpoint used for point-to-point communication.
IpcEndpointBindException: Represents exception occurred during IPC endpoint binding.
IpcEndpointFactory: endpoint factory for inter-process communication.
IpcEndpointType: IPC endpoint type.
IpcServerEndpoint: IPC server endpoint that is capable for client connections accepting.
IpcServerTcpEndpoint: Server loopback IPC endpoint.
IpcToNioAdapter<T>: Allows to re-use existing `GridNioFilter`s on IPC (specifically shared memory IPC) communications.
IsAllPredicate<T>: Predicate that evaluates to `true` if each of its component preds evaluates to `true`.
ISchemaVersion: A serialization schema for HLLs.
IsNotAllPredicate<T>: Negated predicate.
IsNotNullPredicate<E>: Defines a predicate which checks a parameter on `null`.
IsolatedDiscoverySpi: Special discovery SPI implementation to start a single-node cluster in "isolated" mode.
IsolatedNode: Special isolated node.
IWordDeserializer: Reads 'words' of a fixed width, in sequence, from a byte array.
IWordSerializer: Writes 'words' of fixed width, in sequence, to a byte array.
JavaLogger: Logger to use with Java logging.
JavaLoggerFileHandler: File logging handler which skips all the messages until node ID is set.
JavaLoggerFormatter: Formatter for JUL logger.
JavaObjectIndexKey: Represents an index key that stores as Java Object.
JavaObjectKeySerializer: Serializer for representing JO as byte array in inline.
JdbcBatchExecuteRequest: JDBC batch execute request.
JdbcBatchExecuteResult: JDBC batch execute result.
JdbcBinaryBuffer: Buffer storing the binary data.
JdbcBinaryTypeGetRequest: JDBC get binary type metadata request.
JdbcBinaryTypeGetResult: JDBC get binary type metadata result.
JdbcBinaryTypeNameGetRequest: JDBC get binary type name request.
JdbcBinaryTypeNameGetResult: JDBC get binary type name result.
JdbcBinaryTypeNamePutRequest: JDBC put binary type name request.
JdbcBinaryTypePutRequest: JDBC put binary type metadata request.
JdbcBlob: Simple BLOB implementation.
JdbcBulkLoadAckResult: A reply from server to SQL COPY command, which is essentially a request from server to client to send files from client to server (see IGNITE-6917 for details).
JdbcBulkLoadBatchRequest: A JDBC request that sends a batch of a file to the server.
JdbcBulkLoadProcessor: JDBC wrapper around `BulkLoadProcessor` that provides extra logic.
JdbcCachePartitionsRequest: Jdbc thin request for partiton distribution.
JdbcCachePartitionsResult: Jdbc thin partiton result that contains partition mappings.
JdbcCheckpointSpi: This class defines JDBC checkpoint SPI implementation.
JdbcCheckpointSpiMBean: Management bean that provides general administrative and configuration information about jdbc checkpoint SPI.
JdbcClob: CLOB implementation for Ignite JDBC driver.
JdbcColumnMeta: JDBC column metadata.
JdbcColumnMetaV2: JDBC column metadata.
JdbcColumnMetaV3: JDBC column metadata V3.
JdbcColumnMetaV4: JDBC column metadata V4.
JdbcConnection: JDBC connection implementation.
JdbcConnectionContext: JDBC Connection Context.
JdbcCursor: JDBC Cursor.
JdbcDatabaseMetadata: JDBC database metadata implementation.
JdbcDialect: Represents a dialect of SQL implemented by a particular RDBMS.
JdbcDriverPropertyInfo: Extension of `DriverPropertyInfo` that adds convenient constructors.
JdbcIndexMeta: JDBC index metadata.
JdbcIpFinderDialect: SQL dialect to use with `TcpDiscoveryJdbcIpFinder`.
JdbcMessageParser: JDBC message parser.
JdbcMetaColumnsRequest: JDBC get columns metadata request.
JdbcMetaColumnsResult: JDBC columns metadata result.
JdbcMetaColumnsResultV2: JDBC columns metadata result.
JdbcMetaColumnsResultV3: JDBC columns metadata result.
JdbcMetaColumnsResultV4: JDBC columns metadata result.
JdbcMetadataInfo: Facade over `GridKernalContext` to get information about database entities in terms of JDBC.
JdbcMetaIndexesRequest: JDBC indexes metadata request.
JdbcMetaIndexesResult: JDBC indexes metadata result.
JdbcMetaParamsRequest: JDBC SQL query parameters metadata request.
JdbcMetaParamsResult: JDBC SQL query parameters metadata result.
JdbcMetaPrimaryKeysRequest: JDBC get primary keys metadata request.
JdbcMetaPrimaryKeysResult: JDBC primary keys metadata result.
JdbcMetaSchemasRequest: JDBC tables metadata request.
JdbcMetaSchemasResult: JDBC tables metadata result.
JdbcMetaTablesRequest: JDBC tables metadata request.
JdbcMetaTablesResult: JDBC tables metadata result.
JdbcOrderedBatchExecuteRequest: JDBC batch execute ordered request.
JdbcOrderedBatchExecuteResult: JDBC batch execute ordered result.
JdbcParameterMeta: JDBC SQL query parameter metadata.
JdbcPreparedStatement: JDBC prepared statement implementation.
JdbcPrimaryKeyMeta: JDBC primary key metadata.
JdbcProtocolContext: Protocol context for JDBC protocol.
JdbcQuery: JDBC SQL query with parameters.
JdbcQueryCancelRequest: JDBC query cancel request.
JdbcQueryCloseRequest: JDBC query close request.
JdbcQueryDescriptor: JDBC query descriptor used for appropriate query cancellation.
JdbcQueryExecuteMultipleStatementsResult: JDBC query execute result for query with multiple SQL statements.
JdbcQueryExecuteRequest: JDBC query execute request.
JdbcQueryExecuteResult: JDBC query execute result.
JdbcQueryFetchRequest: JDBC query fetch request.
JdbcQueryFetchResult: JDBC query fetch result.
JdbcQueryMetadataRequest: JDBC query metadata request.
JdbcQueryMetadataResult: JDBC query metadata result.
JdbcRawBinarylizable: Interface that allows to implement custom serialization logic to raw binary streams.
JdbcRequest: JDBC request.
JdbcRequestHandler: JDBC request handler.
JdbcResponse: SQL listener response.
JdbcResult: JDBC response result.
JdbcResultInfo: JDBC statement result information.
JdbcResultSet: JDBC result set implementation.
JdbcResultSetMetadata: JDBC result set metadata implementation.
JdbcResultWithIo: Jdbc result with IO.
JdbcSetTxParametersRequest: JDBC sets transactions parameters for connection.
JdbcStatement: JDBC statement implementation.
JdbcStatementResultInfo: JDBC statement result information.
JdbcStatementType: JDBC statement type.
JdbcTableMeta: JDBC table metadata.
JdbcThinConnection: JDBC connection implementation.
JdbcThinDatabaseMetadata: JDBC database metadata implementation.
JdbcThinFeature: Defines supported features for JDBC thin client.
JdbcThinParameterMetadata: JDBC SQL query's parameters metadata.
JdbcThinPartitionAwarenessMappingGroup: Contains cache partitions distributions with corresponding set of cache ids.
JdbcThinPartitionResultDescriptor: Partition result descriptor.
JdbcThinPreparedStatement: JDBC prepared statement implementation.
JdbcThinResultSet: JDBC result set implementation.
JdbcThinResultSetMetadata: JDBC result set metadata implementation.
JdbcThinSSLUtil: SSL utility method to create SSL connetion.
JdbcThinStatement: JDBC statement implementation.
JdbcThinTcpIo: JDBC IO layer implementation based on blocking IPC streams.
JdbcThinUtils: Utility methods for thin JDBC driver.
JdbcTxEndRequest: JDBC ent transaction request.
JdbcTxEndResult: JDBC end transaction result.
JdbcType: Description for type that could be stored into database by store.
JdbcTypeDefaultHasher: Default implementation of `JdbcTypeHasher`.
JdbcTypeField: Description of how field declared in database and in cache.
JdbcTypeHasher: API for implementing custom hashing logic for binary objects on server side.
JdbcTypesDefaultTransformer: Default implementation of `JdbcTypesTransformer`.
JdbcTypesTransformer: API for implementing custom mapping logic for loaded from store data.
JdbcUpdateBinarySchemaResult: JDBC update binary schema result.
JdbcUtils: Utility methods for JDBC driver.
JdbcUtils: Various JDBC utility methods.
JdkMarshaller: Implementation of `Marshaller` based on JDK serialization mechanism.
JmxMetricExporterSpi: Overview
JmxSystemViewExporterSpi: This SPI implementation exports system views as JMX beans.
JobContextResource: Annotates a field or a setter method for injection of `ComputeJobContext` instance.
JobEvent: Grid job event.
JobStealingCollisionSpi: Collision SPI that supports job stealing from over-utilized nodes to under-utilized nodes.
JobStealingCollisionSpiMBean: Management MBean for job stealing based collision SPI.
JobStealingDisabled: This annotation disables job stealing if corresponding feature is configured.
JobStealingFailoverSpi: Job stealing failover SPI needs to always be used in conjunction with `JobStealingCollisionSpi` SPI.
JobStealingFailoverSpiMBean: Management bean for `JobStealingFailoverSpi`.
JobStealingRequest: Job stealing request.
JobWorkerInterruptionTimeoutObject: Timeout object for delayed `worker` interruption.
JvmConfigurationSuggestions: Java Virtual Machine configuration suggestions.
KeyCacheObject
KeyCacheObjectImpl
KeystoreEncryptionKey: `EncryptionKey` implementation based on java security.
KeystoreEncryptionSpi: EncryptionSPI implementation base on JDK provided cipher algorithm implementations.
KillClientCommand
KillClientCommandArg
KillCommand: Kill command.
KillComputeCommand
KillComputeCommandArg
KillConsistencyCommand
KillContinuousCommand
KillContinuousCommandArg
KillScanCommand
KillScanCommandArg
KillServiceCommand
KillServiceCommandArg
KillSnapshotCommand
KillSnapshotCommandArg
KillSqlCommand
KillSqlCommandArg
KillTransactionCommand
KillTransactionCommandArg
KillTransactionTask
Latch: Simple distributed count down latch interface.
LatchAckMessage: Message is used to send acks for `Latch` instances management.
LazyDataEntry: Represents Data Entry (`LazyDataEntry.key()`, `value`) pair update `operation`.
LazyServiceConfiguration: Lazy service configuration.
LeafIO: Leaf page for index rows without inline payload.
LifecycleAware: All components provided in Ignite configuration can implement this interface.
LifecycleBean: A bean that reacts to node lifecycle events defined in `LifecycleEventType`.
LifecycleEventType: Node lifecycle event types.
LightweightCheckpointManager: Like a sharp checkpoint algorithm implemented in `CheckpointManager` this checkpoint ensures that all pages marked dirty under `LightweightCheckpointManager.checkpointTimeoutLock()` will be consistently saved to disk.
LineSplitterBlock: A `PipelineBlock`, which splits input stream of char[] into lines using the specified `Pattern` as line separator.
LinkMap: Class that holds mappings of old links to new links.
LoadAllWarmUpConfiguration: "Load All" warm-up configuration that loads data into persistent data region until it reaches `DataRegionConfiguration.getMaxSize()` with index priority.
LoadAllWarmUpStrategy: "Load all" warm-up strategy, which loads pages to persistent data region until it reaches `DataRegionConfiguration.getMaxSize()` with priority to index partitions.
LoadBalancerResource: Annotates a field or a setter method for injection of `ComputeLoadBalancer`.
LoadBalancingSpi: Load balancing SPI provides the next best balanced node for job execution.
LoadedPagesMap: Interface for storing correspondence of page ID in a cache group to long value (address in offheap segment).
LoadedPagesMap.KeyPredicate: Interface describing a predicate for Key (cache group ID, page ID).
LocalCommand<A extends IgniteDataTransferObject,​R>: Command that must be executed directly using `GridClient` or `Ignite` instance.
LocalDeploymentSpi: Local deployment SPI that implements only within VM deployment on local node via `LocalDeploymentSpi.register(ClassLoader, Class)` method.
LocalDeploymentSpiMBean: Management MBean for `LocalDeploymentSpi` SPI.
LocalJoinCachesContext: Context to capture caches state for a node joining to an active cluster.
LocalStatisticsGatheringContext: Statistics gathering context.
LockedEntriesInfo: Helper class to acquire java level locks on unordered set of entries and avoid deadlocks.
LockedSegmentFileInputFactory: Implementation of factory to provide I/O interfaces for read primitives with files.
LockLog: Abstract page lock log class.
LockStack: Abstract page lock stack.
LogEntry: Log entry.
LogExporterSpi: This SPI implementation exports metrics to Ignite log.
LoggerResource: Annotates a field or a setter method for injection of `IgniteLogger`.
LongAdderMetric: Long metric implementation based on `LongAdder`.
LongAdderWithDelegateMetric: Long metric implementation based on `LongAdder` with `LongAdderWithDelegateMetric.delegate`.
LongAdderWithDelegateMetric.Delegate
LongGauge: Implementation based on primitive supplier.
LongIndexKey
LongInlineIndexKeyType: Inline index column implementation for inlining `Long` values.
LongIterator: A `long`-based iterator.
LongJVMPauseDetector: Class for detection of long JVM pauses.
LongListReuseBag: `GridLongList`-based reuse bag.
LongMetric: Interface for the metrics that holds long primitive.
LongSumReducer: Reducer that calculates sum of long integer elements.
LruEvictionPolicy<K,​V>: Eviction policy based on `Least Recently Used (LRU)` algorithm and supports batch eviction.
LruEvictionPolicyFactory<K,​V>: Factory class for `LruEvictionPolicy`.
LruEvictionPolicyMBean: MBean for `LRU` eviction policy.
LT: Defines internal `typedef` for `GridLogThrottle`.
MaintenanceAction<T>: Maintenance action interface enables user to execute operations related to a particular `MaintenanceTask`.
MaintenanceFileStore: Provides API for durable storage of `MaintenanceTask`s and hides implementation details from higher levels.
MaintenanceProcessor
MaintenanceRebuildIndexTarget: RebuildIndexAction's parameters.
MaintenanceRebuildIndexUtils: Utility methods for the index rebuild maintenance task.
MaintenanceRegistry: `MaintenanceRegistry` is a service local to each Ignite node that allows to request performing maintenance actions on that particular node.
MaintenanceTask: Represents request to handle maintenance situation.
MaintenanceWorkflowCallback: Abstraction to decouple interaction between `MaintenanceRegistry` and components that may require maintenance.
ManagementTaskEvent: Management task started event.
MapFactoryCallable: Hash map factory.
MappedFile
MappedFileMemoryProvider: Memory provider implementation based on memory mapped file.
MappedName: Contains mapped class name and boolean flag showing whether this mapping was accepted by other nodes or not.
MappingAcceptedMessage: Is sent as an acknowledgement for successfully proposed new mapping (see `MappingProposedMessage`).
MappingExchangeResult
MappingProposedMessage: Node sends this message when it wants to propose new marshaller mapping and to ensure that there are no conflicts with this mapping on other nodes in cluster.
MappingUpdatedListener: Interface allows any component to register for events of newly added mappings.
MarshalledRecord: Special type of WAL record.
Marshaller: `Marshaller` allows to marshal or unmarshal objects in grid.
MarshallerContext: Marshaller context.
MarshallerContextImpl: Marshaller context implementation.
MarshallerExclusions: Controls what classes should be excluded from marshalling by default.
MarshallerMappingItem: Used to exchange mapping information on new mapping added or missing mapping requested flows.
MarshallerMappingTransport: Provides capabilities of sending custom discovery events to propose new mapping or request missing mapping to `MarshallerContextImpl`.
MarshallerPlatformIds: Constants for platform IDs to feed into `MarshallerContext`.
MarshallerUtils: Utility marshaller methods.
MasterKeyChangeRecord: Deprecated. Replaced by MasterKeyChangeRecordV2.
MasterKeyChangeRecordV2: Logical record that stores encryption keys.
MemoryAllocator: Base interface for offheap memory allocator.
MemoryCalculator
MemoryConfiguration: Deprecated. Use `DataStorageConfiguration` instead.
MemoryEventStorageSpi: In-memory `EventStorageSpi` implementation.
MemoryEventStorageSpiMBean: Management bean for `MemoryEventStorageSpi`.
MemoryMetrics: Deprecated. Check the `ReadOnlyMetricRegistry` with "name=io.dataregion.
MemoryMetricsCommandHandler: Command handler for a collection of `DataRegionMetrics`
MemoryPolicyConfiguration: Deprecated. Use `DataRegionConfiguration` instead.
MemoryRecoveryRecord: Marker indicates that binary memory recovery has finished.
MergeRecord<L>: Merge on remove.
Message: Base class for all communication messages.
MessageCollectionItemType: Enum representing possible types of collection items.
MessageFactory: Message factory for all communication messages registered using `MessageFactory.register(short, Supplier)` method call.
MessageFactoryProvider: Provider of communication message factories.
MessageFormatter: Provides a custom format for communication messages.
MessageReader: Communication message reader.
MessageWriter: Communication message writer.
MessagingListenActor<T>: Convenience actor-base adapter for `IgniteMessaging.localListen(Object, IgniteBiPredicate)` method.
MetaCommand: Metadata commands.
MetaCommand.MetaHelpCommand
MetadataInfoTask: Task for MetadataListCommand and MetadataDetailsCommand commands.
MetadataListResult: Represents information about cluster metadata.
MetadataMarshalled: Represents information about cluster metadata.
MetadataRemoveAcceptedMessage: Acknowledge message for `MetadataRemoveProposedMessage`: see its javadoc for detailed description of protocol.
MetadataRemoveProposedMessage: MetadataRemoveProposedMessage and `MetadataRemoveAcceptedMessage` messages make a basis for discovery-based protocol for manage `metadata` describing objects in binary format stored in Ignite caches.
MetadataRemoveTask: Task for remove specified binary type.
MetadataRequestMessage: As `DiscoveryCustomMessage` messages are delivered to client nodes asynchronously it is possible that server nodes are allowed to send to clients some BinaryObjects clients don't have metadata for.
MetadataResponseMessage: Carries latest version of metadata to client as a response for `MetadataRequestMessage`.
MetadataUpdateAcceptedMessage: Acknowledge message for `MetadataUpdateProposedMessage`: see its javadoc for detailed description of protocol.
MetadataUpdateProposedMessage: MetadataUpdateProposedMessage and `MetadataUpdateAcceptedMessage` messages make a basis for discovery-based protocol for exchanging `metadata` describing objects in binary format stored in Ignite caches.
MetadataUpdateTask: Task for update specified binary type.
MetaDetailsCommand
MetaDetailsCommandArg
MetaListCommand
MetaPageAddRootRecord: New root in meta page.
MetaPageCutRootRecord
MetaPageInfo: Meta page stores meta data about InlineIndexTree.
MetaPageInitRecord
MetaPageInitRootInlineFlagsCreatedVersionRecord
MetaPageInitRootInlineRecord
MetaPageInitRootRecord: Initialize new meta page.
MetaPageUpdateIndexDataRecord: Meta page delta record, includes encryption status data.
MetaPageUpdateLastAllocatedIndex
MetaPageUpdateLastSuccessfulFullSnapshotId: Deprecated. Will be removed at 3.0.
MetaPageUpdateLastSuccessfulSnapshotId: Deprecated. Will be removed at 3.0.
MetaPageUpdateNextSnapshotId: Deprecated. Will be removed at 3.0.
MetaPageUpdatePartitionDataRecord
MetaPageUpdatePartitionDataRecordV2
MetaPageUpdatePartitionDataRecordV3: Partition meta page delta record includes encryption status data.
MetaRemoveCommand
MetaRemoveCommandArg
MetaStorage: General purpose key-value local-only storage.
MetaStorage.TmpStorage: Temporary storage
MetastorageBPlusIO
MetastorageDataRow
MetastorageInnerIO
MetastorageLeafIO
MetastorageLifecycleListener: Listener for events of metastore lifecycle.
MetastoragePageIOUtils: `MetastorageInnerIO` and `MetastorageLeafIO` use the same page format but cannot explicitly share the same implementation, because they are inherited from two independant abstract classes.
MetastorageRow: BPlus row hierarchy is broken.
MetastorageRowStore
MetastorageRowStoreEntry
MetastorageSearchRow
MetastorageTree
MetastorageView: Metastorage key representation for a `SystemView`.
MetastorageViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
MetastoreDataPageIO: Data pages IO for using with meta store.
MetastoreDataRecord
MetaUpdateCommand
MetaUpdateCommandArg
Metric: Base interface for all metrics.
MetricCommand: Command for printing metric values.
MetricCommandArg
MetricConfigureHistogramCommand
MetricConfigureHistogramCommandArg
MetricConfigureHitrateCommand
MetricConfigureHitrateCommandArg
MetricExporterSpi: Exporter of metric information to the external recipient.
MetricRegistry: Metric registry.
MetricRegistryImpl: Metric registry.
MetricRegistryMBean: MBean for exporting values of metric registry.
MetricsAwareExecutorService: Executor service that supports self-registration of metrics.
MetricsMxBean: Deprecated. Use managements API beans, instead.
MetricsMxBeanImpl: `MetricsMxBean` implementation.
MetricsView: Metrics representation for a `SystemView`.
MetricsViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
MetricTask: Reperesents visor task for obtaining metric values.
MetricUtils: Utility class to build or parse metric name in dot notation.
MissingMappingRequestMessage: Client node receives discovery messages in asynchronous mode so it is possible that all server nodes already accepted new mapping but clients are unaware about it.
MissingMappingResponseMessage: On receiving a `MissingMappingRequestMessage` mapping request server node looks up class name for requested platformId and typeId in its local marshaller cache and sends back a `MissingMappingResponseMessage` mapping response with resolved class name.
MTC: Mapped tracing context.
MTC.TraceSurroundings: Helper for managing of span life cycle.
MultipleIterator<T>: Concatenates multiple iterators as single one.
MutableSingletonList<E>: List that can contain maximum of one element.
MXBeanDescription: Provides description for MBean classes and methods.
MXBeanParameter: Provides name and description for MBean method parameter.
MXBeanParametersDescriptions: Deprecated. Use `MXBeanParameter` instead.
MXBeanParametersNames: Deprecated. Use `MXBeanParameter` instead.
MySQLDialect: A dialect compatible with the MySQL database.
NativeFileSystem: Native file system API.
NearCacheConfiguration<K,​V>: Client (near) cache configuration.
NearCacheUpdates
NearTxFinishFuture
NeverFailoverSpi: This class provides failover SPI implementation that never fails over.
NeverFailoverSpiMBean: Management bean for `NeverFailoverSpi`.
NewRootInitRecord<L>: Initialize new root page.
NoArg: Utility class for commands without any specific arguments.
NodeAttributeView: Node attribute representation for a `SystemView`.
NodeAttributeViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
NodeIdMessage: Node ID message.
NodeMetricsView: Node metrics representation for a `SystemView`.
NodeMetricsViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
NodeOrderComparator: Node order comparator.
NodeOrderLegacyComparator: Node order comparator.
NodePage<R>: Represents a single page with results of cache query from single node.
NodePageStream<R>: This class provides an interface `NodePageStream.headPage()` that returns a future will be completed with `NodePage` of cache query result from single node.
NodeStateBeforeStartCommandHandler: Command handler for managing state of a node before it starts and getting information about it.
NodeStoppingException
NodeUnreachableException: Exception is thrown by `TcpCommunicationSpi` when some or all addresses of a node are unreachable and direct communication connection cannot be established.
NodeValidationFailedEvent: This event is triggered if any of `GridComponent`s fail to validate the joining node while join message processing.
NoMatchingCachesException: Runtime exception that can be thrown in `VerifyBackupPartitionsTaskV2` when no caches matching given filter options can be found.
NoOpBinary
NoopCheckpointSpi: No-op implementation of `CheckpointSpi`.
NoOpClosure: Absolute closure that does nothing.
NoopCollisionSpi: No-op implementation of `CollisionSpi`.
NoopDependencyResolver: Noop implementation of dependency resolver.
NoopEncryptionSpi: No operation `EncryptionSPI` implementation.
NoopEventStorageSpi: No-op implementation of `EventStorageSpi`.
NoOpFailureHandler: Just ignores any failure.
NoOpIgniteSecurityProcessor: No operation IgniteSecurity.
NoopIndexingSpi: Default implementation of `IndexingSpi` which does not index cache.
NoopMetricExporterSpi: No-op implementation of metric exporter SPI.
NoOpPageEvictionTracker
NoOpQueryEngine: No op implementation.
NoOpSandbox: No operation Sandbox.
NoopSpan: Noop and null-safe implementation of Span.
NoopSpiSpecificSpan: Noop and null-safe implementation of `SpiSpecificSpan`.
NoopTracing: Noop implementation of `Tracing`.
NoopTracingConfigurationManager: Noop tracing configuration manager.
NoopTracingSpi: Noop and null-safe implementation of Tracing SPI.
NoOpWarmUpConfiguration: Noop warm-up configuration.
NoOpWarmUpStrategy: Noop warming up strategy.
NotContainsPredicate<T>: Predicate that returns `true` if its free variable is not contained in given collection.
NotEqualPredicate<T>: Predicate that evaluates to `true` if its free variable is equal to `target` or both are `null`.
NotWritablePropertyException: Exception of distributed property still have not been allowed for write value.
NullableInlineIndexKeyType<T extends IndexKey>: Abstract inline key.
NullIndexKey: Represents null value stored in index row or query.
NullLogger: Logger which does not output anything.
NullsOrder: Enum to store possible nulls ordering.
NumberUtil: A collection of utilities to work with numbers.
NumericIndexKey: Class that represnts a numeric index key.
NumericInlineIndexKeyType<T extends IndexKey>: Inline index key implementation for inlining numeric values.
ObjectByteArrayInlineIndexKeyType: Inline index key implementation for inlining Java Objects as byte array.
ObjectGauge<T>: Implementation based on primitive supplier.
ObjectHashInlineIndexKeyType: Inline index key implementation for inlining hash of Java objects.
ObjectMetric<T>: Interface for the metrics that holds typed value.
ObjectMetricImpl<T>: Implementation of `ObjectMetric`.
ObjectPartitionStatisticsImpl: Statistic for some partition of data object.
ObjectPartitionStatisticsObsolescence: Partition obsolescence tracker.
ObjectStatistics: Any type of object statistics.
ObjectStatisticsEvent: Local object statistics change event.
ObjectStatisticsImpl: All statistics by some object (table or index).
OdbcColumnMeta: SQL listener column metadata.
OdbcConfiguration: Deprecated.
OdbcConnectionContext: ODBC Connection Context.
OdbcEscapeParseResult: ODBC escape sequence parse result.
OdbcEscapeToken: ODBC escape sequence token.
OdbcEscapeType: ODBC escape sequence type.
OdbcEscapeUtils: ODBC escape sequence parse.
OdbcMessageParser: JDBC message parser.
OdbcQuery: ODBC SQL query with parameters.
OdbcQueryCloseRequest: SQL listener query close request.
OdbcQueryCloseResult: SQL listener query close result.
OdbcQueryExecuteBatchRequest: ODBC query execute request with the batch of parameters.
OdbcQueryExecuteBatchResult: ODBC query execute with batch of parameters result.
OdbcQueryExecuteRequest: SQL listener query execute request.
OdbcQueryExecuteResult: SQL listener query execute result.
OdbcQueryFetchRequest: SQL listener query fetch request.
OdbcQueryFetchResult: SQL listener query fetch result.
OdbcQueryGetColumnsMetaRequest: ODBC query get columns meta request.
OdbcQueryGetColumnsMetaResult: Query get columns meta result.
OdbcQueryGetParamsMetaRequest: ODBC query get params meta request.
OdbcQueryGetParamsMetaResult: ODBC query get params meta result.
OdbcQueryGetQueryMetaRequest: ODBC query get query meta request.
OdbcQueryGetResultsetMetaRequest: ODBC query get params meta request.
OdbcQueryGetResultsetMetaResult: SQL listener query resultset metadata result.
OdbcQueryGetTablesMetaRequest: ODBC query get tables meta request.
OdbcQueryGetTablesMetaResult: Query get columns meta result.
OdbcQueryMoreResultsRequest: SQL listener query fetch request.
OdbcQueryMoreResultsResult: SQL listener query fetch result.
OdbcQueryResults: ODBC result set
OdbcRequest: SQL listener command request.
OdbcRequestHandler: SQL query handler.
OdbcResponse: SQL listener response.
OdbcResultSet: Represents single result set.
OdbcStreamingBatchRequest: ODBC query execute request with the batch of parameters.
OdbcStreamingBatchResult: ODBC query execute with batch of parameters result.
OdbcTableMeta: ODBC table-related metadata.
OdbcTypes: Data type names that can occur within ODBC escape sequence
OdbcUtils: Various ODBC utility methods.
OffHeapPageMetaInfoStore
OffheapReadWriteLock: Lock state structure is as follows:
OomExceptionHandler: OOM exception handler for system threads.
Operation: Operation type for `PageLocksTask`
OperationSecurityContext
OperationType: Performance statistics operation type.
OptimizedMarshaller: Optimized implementation of `Marshaller`.
OptimizedMarshallerIdMapper: ID mapper.
OptimizedMarshallerInaccessibleClassException
OptimizedObjectOutputStream: Optimized object output stream.
OptimizedObjectPooledStreamRegistry
OptimizedObjectSharedStreamRegistry
OracleDialect: A dialect compatible with the Oracle database.
OracleJdbcIpFinderDialect: Oracle JDBC dialect to use along with `TcpDiscoveryJdbcIpFinder`.
Order: Represents ordering of rows within sorted index.
Order: Annotation to set walk order for a `SystemViewRowAttributeWalker`.
OsConfigurationSuggestions: Operation System configuration suggestions.
OsDiscoveryNodeValidationProcessor: Node validation.
P1<E1>: Defines `alias` for `IgnitePredicate` by extending it.
P2<T1,​T2>: Defines `alias` for `IgniteBiPredicate` by extending it.
P2PClassLoadingIssues
P2PClassNotFoundException: A specialication of `ClassNotFoundException` thrown when a class cannot be loaded during P2P class-loading.
P3<T1,​T2,​T3>: Defines `alias` for `GridPredicate3` by extending it.
PA: Defines `alias` for `GridAbsPredicate` by extending it.
PageAbstractEvictionTracker
PageDeltaRecord: Abstract page delta record.
PageEvictionTracker: Entry point for per-page eviction.
PageHandler<X,​R>: Page handler.
PageHandlerWrapper<R>: Wrapper factory for `PageHandler` instances.
PageIdAllocator: Allocates page ID's.
PageIdUtils: Utility class for page ID parts manipulation.
PageIO: Base format for all the page types.
PageIoResolver
PageListMetaResetCountRecord: Delta record for page-list meta count reset
PageLockDump: Base page lock tracker structures dump.
PageLockListener: Page lock listener.
PageLockLogSnapshot: Page lock log snapshot.
PageLocksResult
PageLockStackSnapshot: Page lock stack snapshot.
PageLocksTask
PageLockTracker<T extends PageLockDump>: Abstract page lock tracker.
PageLockTrackerFactory: Page lock tracker factory. 1 - HEAP_STACK 2 - HEAP_LOG 3 - OFF_HEAP_STACK 4 - OFF_HEAP_LOG
PageLockTrackerManager: Page lock manager.
PageLockTrackerMXBean: This interface defines JMX managment interface for page lock tracking.
PageLockTrackerMXBeanImpl: Implementation of `PageLockTrackerMXBean`.
PageMemory
PageMemoryEx: Page memory with some persistence related additions.
PageMemoryImpl: Page header structure is described by the following diagram.
PageMemoryImpl.ThrottlingPolicy: Throttling enabled and its type enum.
PageMemoryNoStoreImpl: Page header structure is described by the following diagram.
PageMetaInfoStore
PageMetaIO
PageMetaIOV2: IO for index partition metadata page.
PageMetrics: Container for different memory page-related metrics.
PageMetricsImpl
PageMetricsImpl.Builder: Builder for `PageMetricsImpl` instances.
PagePartitionCountersIO: Page IO for Partition Counters, IO for pages containing cache ID mapping to its size.
PagePartitionMetaIO: IO for partition metadata pages.
PagePartitionMetaIOV2: IO for partition metadata pages.
PagePartitionMetaIOV3: IO for partition metadata pages.
PagePool
PageReadWriteManager
PageReadWriteManagerImpl
PageReplacementMode: Defines memory page replacement algorithm.
PageReplacementPolicy: Abstract page replacement policy.
PageReplacementPolicyFactory: Page replacement policy factory.
PageReplacementStartedEvent: Event type indicating that page replacement started in one of the configured data regions.
PagesAllocationRange: Range of pages allocated.
PagesList: Striped doubly-linked list of page IDs optionally organized in buckets.
PagesList.PagesCache: Class to store page-list cache onheap.
PagesList.Stripe
PagesListAddPageRecord
PagesListInitNewPageRecord
PagesListMetaIO
PagesListNodeIO: TODO optimize: now we have slow `PagesListNodeIO.removePage(long, long)`
PagesListRemovePageRecord
PagesListSetNextRecord
PagesListSetPreviousRecord
PagesListView: Pages-list representation for a `SystemView`.
PagesListViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
PageSnapshot
PagesTimestampHistogramView: Pages timestamp histogramm representation for a `SystemView`.
PagesTimestampHistogramViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
PageStore: Persistent store of pages.
PageStoreCollection: A collection that contains `PageStore` elements.
PageStoreWriter: Interface for write page to `PageStore`.
PageSupport: Supports operations on pages.
PagesWriteSpeedBasedThrottle: Throttles threads that generate dirty pages during ongoing checkpoint.
PagesWriteThrottle: Throttles threads that generate dirty pages during ongoing checkpoint.
PagesWriteThrottlePolicy: Throttling policy, encapsulates logic of delaying write operations.
PageUtils
PageWriteListener: Each page write attempt to a `FilePageStore` may be covered by such listener.
PartitionAffinityFunctionType: Affinity function type.
PartitionAllNode: Node denoting all available partitions
PartitionAllocationMap: Information structure with partitions state.
PartitionClearingStartRecord: Partition clearing started record.
PartitionClientContext: Client context.
PartitionCompositeNode: Composite node which consists of two child nodes and a relation between them.
PartitionCompositeNodeOperator: Composite node operator.
PartitionConstantNode: Node with constant partition.
PartitionDataTypeUtils: Utility methods for partition extractor.
PartitionDefferedDeleteQueueCleanupTask: Task to periodically clean partition deffered delete queue.
PartitionDestroyQueue: Partition destroy queue.
PartitionDestroyRecord
PartitionDestroyRequest: Partition destroy request.
PartitionEntryHashRecord
PartitionGroupNode: Flat group of partitions.
PartitionHashRecord: Record containing partition checksum, primary flag and consistent ID of owner.
PartitionHashRecordV2: Record containing partition checksum, primary flag and consistent ID of owner.
PartitionHashRecordV2.PartitionState
PartitionJoinCondition: Join condition.
PartitionJoinGroup: Group of joined tables whose affinity function could be "merged".
PartitionKey: Partition key - pair of cache group ID and partition ID.
PartitionKeyV2: Partition key - pair of cache group ID and partition ID.
PartitionLossPolicy: Partition loss policy.
PartitionMetaStateRecord
PartitionMetaStorage<T extends Storable>: Provides a way to associate any `Storable` implementation as partition metadata.
PartitionMetaStorageImpl<T extends Storable>
PartitionNode: Common node of partition tree.
PartitionNoneNode: Node denoting empty partition set.
PartitionParameterNode: Node with partition which should be extracted from argument.
PartitionParameterType: Partition argument type.
PartitionRecoverState: Class holds state of partition during recovery process.
PartitionResolver: Partition resolver interface.
PartitionResult: Partition extraction result.
PartitionResultMarshaler: Marshaller that lets to serialize and deserialize partiton result for the purposes of jdbc thin client size best effort affinity.
PartitionsEvictManager: Class that serves asynchronous part eviction process.
PartitionsExchangeAware: Interface which allows to subscribe a component for partition map exchange events (via `GridCachePartitionExchangeManager.registerExchangeAwareComponent(PartitionsExchangeAware)`).
PartitionSingleNode: Node with a single partition.
PartitionStateView: Partition state representation for a `SystemView`.
PartitionStateViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
PartitionTable: Single table with affinity info.
PartitionTableAffinityDescriptor: Affinity function descriptor.
PartitionTableModel: Partition join model.
PartitionUpdateCounter: Partition update counter maintains three entities for tracking partition update state.
PartitionUpdateCounterDebugWrapper: Update counter wrapper with logging capabilities.
PartitionUpdateCounterErrorWrapper: Update counter wrapper for error logging.
PartitionUpdateCountersMessage: Partition update counters message.
PartitionUpdateCounterTrackingImpl: Update counter implementation used for cache groups in persistent mode for both tx and atomic caches.
PartitionUpdateCounterVolatileImpl: Partition update counter for volatile caches.
PAX: Defines `alias` for `GridAbsPredicateX` by extending it.
PCE<K,​V>: Defines `alias` for `GridPredicate<Entry<K, V>>` by extending `IgnitePredicate`.
PdsConsistentIdProcessor: Component for resolving PDS storage file names, also used for generating consistent ID for case PDS mode is enabled
PdsFolderResolver<L extends FileLockHolder>: This class contains logic to resolve and possibly lock PDS folder based on provided `IgniteConfiguration` and `PdsFolderResolver.consistentId`.
PdsFolderResolver.FolderCandidate: Represents parsed new style file and encoded parameters in this file name
PdsFolderSettings<L extends FileLockHolder>: Class holds information required for folder generation for ignite persistent store
PdsFoldersResolver: Resolves folders for PDS mode, may have side effect as setting random UUID as local node consistent ID.
PE: Defines `alias` for `GridPredicate<GridEvent>` by extending `IgnitePredicate`.
PendingDiscoveryEvent
PendingEntriesTree
PendingEntryInnerIO
PendingEntryLeafIO
PendingRow
PendingRowIO
PerformanceStatisticsCommand: Command to manage performance statistics.
PerformanceStatisticsCommand.PerformanceStatisticsRotateCommandArg
PerformanceStatisticsCommand.PerformanceStatisticsStartCommandArg
PerformanceStatisticsCommand.PerformanceStatisticsStatusCommandArg
PerformanceStatisticsCommand.PerformanceStatisticsStopCommandArg
PerformanceStatisticsHandler: The interface represents performance statistics operations collection for purposes of troubleshooting and performance analysis.
PerformanceStatisticsMBean: Deprecated. Use managements API beans, instead.
PerformanceStatisticsMBeanImpl: `PerformanceStatisticsMBean` implementation.
PerformanceStatisticsProcessor: Performance statistics processor.
PerformanceStatisticsProcessor.PerformanceStatisticsStateListener: Performance statistics state listener.
PerformanceStatisticsRotateCommand
PerformanceStatisticsStartCommand
PerformanceStatisticsStatusCommand
PerformanceStatisticsStopCommand
PerformanceStatisticsTask: Represents visor task to manage performance statistics.
PeriodicHistogramMetricImpl: Histogram to show count of items for each time interval with limited set of intervals.
PersistenceAbstractCommand
PersistenceBackupAllCommand
PersistenceBackupCachesCommand
PersistenceBackupCachesTaskArg
PersistenceBackupCommand
PersistenceBackupCorruptedCommand
PersistenceCleanAllCommand
PersistenceCleanCachesCommand
PersistenceCleanCachesTaskArg
PersistenceCleanCommand
PersistenceCleanCorruptedCommand
PersistenceCommand
PersistenceCommand.PersistenceBackupAllTaskArg
PersistenceCommand.PersistenceBackupCorruptedTaskArg
PersistenceCommand.PersistenceCleanAllTaskArg
PersistenceCommand.PersistenceCleanCorruptedTaskArg
PersistenceCommand.PersistenceInfoTaskArg
PersistenceCommand.PersistenceTaskArg
PersistenceInfoCommand
PersistenceTask
PersistenceTaskResult
PersistentStoreConfiguration: Deprecated. Use `DataStorageConfiguration` instead.
PipelineBlock<I,​O>: A file parsing pipeline block.
PKV<K,​V>: Defines `alias` for `GridPredicate2<K, V>` by extending `IgnitePredicate`.
PlainJavaObjectIndexKey
PlatformAbstractBootstrap: Base interop bootstrap implementation.
PlatformAbstractConfigurationClosure: Abstract interop configuration closure.
PlatformAbstractFunc: Base class for simple computations (Callable, Runnable).
PlatformAbstractJob: Base interop job.
PlatformAbstractMemory: Interop memory chunk abstraction.
PlatformAbstractPredicate: Base interop predicate.
PlatformAbstractQueryCursor<T>
PlatformAbstractService: Base platform service implementation.
PlatformAbstractTarget: Abstract interop target.
PlatformAbstractTask: Base class for all interop tasks.
PlatformAffinity: Affinity wrapper for platforms.
PlatformAffinityFunction: Platform AffinityFunction.
PlatformAffinityFunctionTarget: Platform affinity function target: to be invoked when Platform function calls base implementation of one of the AffinityFunction methods.
PlatformAffinityManager: AffinityManager wrapper for platforms.
PlatformAffinityUtils: Affinity serialization functions.
PlatformAsyncResult: Represents asynchronous operation result.
PlatformAtomicLong: Platform atomic long wrapper.
PlatformAtomicReference: Platform atomic reference wrapper.
PlatformAtomicSequence: Platform atomic sequence wrapper.
PlatformBalancingMultiClosureTask: Interop multi-closure task with node balancing.
PlatformBalancingSingleClosureTask: Interop single-closure task with node balancing.
PlatformBigEndianInputStreamImpl: Interop input stream implementation working with BIG ENDIAN architecture.
PlatformBigEndianOutputStreamImpl: Interop output stream implementation working with BIG ENDIAN architecture.
PlatformBinaryProcessor: Platform binary processor.
PlatformBootstrap: Platform bootstrap.
PlatformBootstrapFactory: Platform bootstrap factory.
PlatformBroadcastingMultiClosureTask: Interop multi-closure task with broadcast semantics.
PlatformBroadcastingSingleClosureTask: Interop single-closure task with broadcast semantics.
PlatformCache: Native cache wrapper implementation.
PlatformCacheConfiguration: Platform cache configuration.
PlatformCacheEntryFilter: Platform cache entry filter interface.
PlatformCacheEntryFilterImpl: Interop filter.
PlatformCacheEntryProcessor: Platform cache entry processor marker interface.
PlatformCacheEntryProcessorImpl: Platform cache entry processor.
PlatformCacheExtension: Platform cache extension.
PlatformCacheIterator: Interop cache iterator.
PlatformCacheManager: Platform cache manager - delegates functionality to native platforms (.NET, C++, ...).
PlatformCacheObjectImpl: Wraps value provided by platform, must be transformed before stored in cache.
PlatformCachePartialUpdateException: Interop cache partial update exception.
PlatformCachePluginConfiguration: Platform cache plugin configuration.
PlatformCachePluginConfigurationClosure: Platform cache configuration handler: updates plugin configuration using data sent from platform code.
PlatformCachePluginConfigurationClosureFactory: Factory for @`PlatformCachePluginConfigurationClosure` with a unique id.
PlatformCacheStore: Marker interface denoting that this instance is platform cache store.
PlatformCallable: Callable implementation that delegates to native platform.
PlatformCallbackGateway: Gateway to all platform-dependent callbacks.
PlatformCallbackUtils: Platform callback utility methods.
PlatformClosureJob: Light-weight interop job.
PlatformClusterGroup: Interop projection.
PlatformClusterNodeFilter: Platform cluster node filter marker interface.
PlatformClusterNodeFilterImpl: Interop cluster node filter.
PlatformCompute: Interop compute.
PlatformComputeTaskSession: `ComputeTaskSession` platform wrapper.
PlatformConfiguration: Platform configuration marker interface.
PlatformConfigurationEx: Extended platform configuration.
PlatformConfigurationUtils: Configuration utils.
PlatformContext: Platform context.
PlatformContextImpl: Implementation of platform context.
PlatformContinuousQuery: Platform continuous query.
PlatformContinuousQueryFilter: Platform continuous query filter.
PlatformContinuousQueryImpl: Interop continuous query handle.
PlatformContinuousQueryProxy: Proxy that implements PlatformTarget.
PlatformContinuousQueryRemoteFilter: Continuous query filter deployed on remote nodes.
PlatformCppBootstrap: Platform .Net bootstrap.
PlatformCppBootstrapFactory: Platform .Net bootstrap factory.
PlatformCppConfiguration: Platform CPP configuration.
PlatformCppConfigurationClosure: Interop CPP configuration closure.
PlatformCppConfigurationEx: Internal interop CPP configuration.
PlatformDataStreamer: Interop data streamer wrapper.
PlatformDefaultJavaObjectFactory<T>: Default Java object factory implementation.
PlatformDotNetAffinityFunction: AffinityFunction implementation which can be used to configure .NET affinity function in Java Spring configuration.
PlatformDotNetBinaryConfiguration: Mirror of .Net class BinaryConfiguration.cs
PlatformDotNetBinaryTypeConfiguration: Mirror of .Net class BinaryTypeConfiguration.cs
PlatformDotNetBootstrap: Interop .Net bootstrap.
PlatformDotNetBootstrapFactory: Interop .Net bootstrap factory.
PlatformDotNetCacheStore<K,​V>: Wrapper for .NET cache store implementations.
PlatformDotNetCacheStoreFactory: Wrapper for .NET cache store implementations.
PlatformDotNetCacheStoreFactoryNative: Cache store factory that wraps native factory object.
PlatformDotNetConfiguration: Mirror of .Net class IgniteConfiguration.cs
PlatformDotNetConfigurationClosure: Closure to apply dot net configuration.
PlatformDotNetConfigurationEx: Extended .Net configuration.
PlatformDotNetConsoleStream: Stream that writes to the .NET console.
PlatformDotNetEntityFrameworkCacheEntry: EntityFramework cache entry.
PlatformDotNetEntityFrameworkCacheExtension: EntityFramework cache extension.
PlatformDotNetEntityFrameworkCacheKey: EntityFramework cache key: query + versions.
PlatformDotNetEntityFrameworkIncreaseVersionProcessor: Entry processor that increments entity set version number.
PlatformDotNetLifecycleBean: Lifecycle bean implementation which can be used to configure .Net lifecycle beans in Java Spring configuration.
PlatformDotNetService: Marker interface to denote a service implemented on .Net platform.
PlatformDotNetServiceImpl: Interop .Net service.
PlatformDotNetSessionCacheExtension: Custom entry processor invoker.
PlatformDotNetSessionData: Web session state data.
PlatformDotNetSessionLockProcessor: Entry processor that locks web session data.
PlatformDotNetSessionLockResult: Result of the `PlatformDotNetSessionLockProcessor` execution.
PlatformDotNetSessionSetAndUnlockProcessor: Processor to unlock and optionally update the session.
PlatformEventFilterListener: Platform event filter and listener.
PlatformEventFilterListenerImpl: Platform event filter.
PlatformEvents: Interop events.
PlatformException: Interop checked exception.
PlatformExpiryPolicy: Platform expiry policy.
PlatformExpiryPolicyFactory: Platform expiry policy factory.
PlatformExtendedException: Denotes an exception which has some data to be written in a special manner.
PlatformExternalMemory: Interop external memory chunk.
PlatformFieldsQueryCursor: Interop cursor for fields query.
PlatformFullJob: Wrapper around job created in native platform.
PlatformFullTask: Interop task which requires full execution cycle.
PlatformFutureUtils: Interop future utils.
PlatformFutureUtils.Writer: Writer allowing special future result handling.
PlatformIgnition: Entry point for platform nodes.
PlatformInputStream: Interop output stream,
PlatformInputStreamImpl: Interop input stream implementation.
PlatformJavaObjectFactory<T>: Object factory used for advanced interop between platform and Java.
PlatformJavaObjectFactoryEx<T>: Extended Java object factory interface to handle special cases.
PlatformJavaObjectFactoryProxy: Wrapper for Java object factory.
PlatformJavaObjectSingletonFactory<T>: Singleton factory.
PlatformJob: Platform closure job interface.
PlatformLifecycleBean: Lifecycle aware bean for interop.
PlatformListenable: Platform listenable.
PlatformListenableTarget: Wraps listenable in a platform target.
PlatformLocalEventListener: Platform local event filter.
PlatformLogger: Logger that delegates to platform.
PlatformMemory: Interop memory chunk.
PlatformMemoryManager: Interop memory manager interface.
PlatformMemoryManagerImpl: Interop memory manager implementation.
PlatformMemoryPool: Memory pool associated with a thread.
PlatformMemoryUtils: Utility classes for memory management.
PlatformMessageFilter: Platform message filter.
PlatformMessageFilterImpl: Platform message filter.
PlatformMessageLocalFilter: Interop local filter.
PlatformMessaging: Interop messaging.
PlatformNativeException: Exception occurred on native side.
PlatformNoCallbackException: Exception raised when interop callback is not set in native platform.
PlatformNoopProcessor: No-op processor.
PlatformOutputStream: Interop output stream.
PlatformOutputStreamImpl: Interop output stream implementation.
PlatformPluginConfigurationClosure: Platform configuration handler: updates plugin configuration using data sent from platform code.
PlatformPluginConfigurationClosureFactory: Factory for @`PlatformPluginConfigurationClosure` with a unique id.
PlatformPluginExtension: Platform extension.
PlatformPluginProcessor: Platform plugin processor
PlatformPooledMemory: Interop pooled memory chunk.
PlatformProcessor: Platform processor.
PlatformProcessorImpl: Platform processor.
PlatformQueryCursor: Interop cursor for regular queries.
PlatformReaderBiClosure<T1,​T2>: Reader bi-closure.
PlatformReaderClosure<T>: Reader closure.
PlatformRunnable: Runnable implementation that delegates to native platform.
PlatformSecurityAwareJob: Represents the base interface for all Platform Compute Jobs that wrap and execute user code.
PlatformService: Base class for all platform services.
PlatformServiceConfiguration: Extended service configuration.
PlatformServiceMethod: Annotation for setting mapping between java interface's method and platform service's method.
PlatformServices: Interop services.
PlatformStreamReceiver: Platform data streamer filter marker interface.
PlatformStreamReceiverImpl: Interop receiver.
PlatformTarget: Interop target abstraction.
PlatformTargetProxy: Platform target that is invoked via JNI and propagates calls to underlying `PlatformTarget`.
PlatformTargetProxyImpl: Platform target that is invoked via JNI and propagates calls to underlying `PlatformTarget`.
PlatformTransactions: Native transaction wrapper implementation.
PlatformType: Interop platform type.
PlatformUnpooledMemory: Interop un-pooled memory chunk.
PlatformUtils: Platform utility methods.
PlatformWriterBiClosure<T1,​T2>: Interop writer bi-closure.
PlatformWriterClosure<T>: Interop writer closure.
PluginConfiguration: Plugin configuration.
PluginContext: Plugin context.
PluginNotFoundException: Exception thrown if plugin is not found.
PluginProvider<C extends PluginConfiguration>: Pluggable Ignite component.
PluginValidationException: Plugin validation exception.
PN: Defines `alias` for `GridPredicate<ClusterNode>` by extending `IgnitePredicate`.
PoolProcessor: Processor which abstracts out thread pool management.
Positional: This annotation required only for CLI utilities such as `control.sh`.
PredicateCollectionView<T>: Light-weight view on given col with provided predicate.
PredicateMapView<K,​V>: Light-weight view on given map with provided predicate.
PredicateSetView<K,​V>: Light-weight view on given map with provided preds and mapping.
PreparableCommand<A extends IgniteDataTransferObject,​R>
PrintRawToFileHandler: Handler to print raw pages data into file for further diagnostic.
PriorityQueueCollisionSpi: This class provides implementation for Collision SPI based on priority queue.
PriorityQueueCollisionSpiMBean: Management bean that provides access to the priority queue collision SPI configuration.
PropertiesListResult: List of the distributed properties names.
PropertiesListTask: Task for property operations.
PropertyCommand: Commands to manage distributed properties.
PropertyCommand.PropertyHelpCommand
PropertyGetCommand
PropertyGetCommandArg
PropertyListCommand
PropertyListCommandArg
PropertyOperationResult: Result of an operation with property.
PropertySetCommand
PropertySetCommandArg
PropertyTask: Task for property operations.
PropertyUpdateClosure: Closure of cluster wide update of distributed property.
ProtocolBitmaskFeature: Defines supported bitmask features for thin client.
ProtocolContext: Protocol Context.
ProtocolVersion: Thin client protocol version.
ProtocolVersionFeature: Thin client feature that was introduced by introducing new protocol version.
PublicAccessJob: Represents an interface that must be implemented by any internal `ComputeJob` that should be accessible for a user to be executed through the Ignite public API.
PureJavaCrc32: Deprecated. Use `FastCrc` instead.
PushMetricsExporterAdapter: Base class for exporters that pushes metrics to the external system.
PX1<E1>: Defines `alias` for `IgnitePredicateX` by extending it.
PX2<T1,​T2>: Defines `alias` for `IgnitePredicate2X` by extending it.
PX3<T1,​T2,​T3>: Defines `alias` for `GridPredicate3X` by extending it.
QualifiedSQLQuery: Qualified sql query: schema + query itself.
Query<R>: Main API for configuring and executing cache queries.
QueryBinaryProperty: Binary property.
QueryCancellable: Cancellable query interface.
QueryCancelledException: The exception is thrown if a query was cancelled or timed out while executing.
QueryCancelOnInitiatorTask: Task to cancel queries on initiator node.
QueryClassProperty: Description of type property.
QueryCommandHandler: Query command handler.
QueryConfiguration: Data transfer object for cache query configuration data.
QueryContext
QueryCursor<T>: Query result cursor.
QueryCursorEx<T>: Extended query cursor interface allowing for "getAll" to output data into destination other than Collection.
QueryCursorEx.Consumer<T>: Query value consumer.
QueryCursorImpl<T>: Query cursor implementation.
QueryCursorImpl.State: Query cursor state
QueryDetailMetrics: Query metrics aggregated by query type and its textual representation.
QueryEngine
QueryEngineConfiguration: Interface for the configuration of the query engine.
QueryEngineConfigurationEx: Internal interface for the query engine configuration.
QueryEntity: Query entity is a description of `cache` entry (composed of key and value) in a way of how it must be indexed and can be queried.
QueryEntity: Data transfer object for `QueryEntity`.
QueryEntityClassProperty: Description of type property.
QueryEntityEx: Extended query entity with not-null fields support.
QueryEntityIndexDescriptor: Index descriptor.
QueryEntityPatch: Query entity patch which contain `SchemaAbstractOperation` operations for changing query entity.
QueryEntityTypeDescriptor: Descriptor of type.
QueryField: Query field metadata.
QueryFieldAccessor: Accessor that deals with fields.
QueryGroupIndex: Describes group index.
QueryGroupIndex.List: List of group indexes for type.
QueryHistory: Query history metrics.
QueryHistoryKey: Immutable query metrics key used to group metrics.
QueryIndex: Contains list of fields to be indexed.
QueryIndex: Data transfer object for `QueryIndex`.
QueryIndexDefinition: Define query index.
QueryIndexDescriptorImpl: Index descriptor.
QueryIndexField: Data transfer object for `QueryEntity`.
QueryIndexKey: Index key.
QueryIndexRowHandler: Maps CacheDataRow to IndexRow using columns references.
QueryIndexRowHandlerFactory: This factory applies tree's meta page info to build info about inlined types.
QueryIndexType: Index type.
QueryKeyValueIterable<K,​V>: SqlQuery key-value iterable.
QueryKeyValueIterator<K,​V>: SqlQuery key-value iterator.
QueryMethodsAccessor: Getter and setter methods based accessor.
QueryMetrics: Cache query metrics used to obtain statistics on query.
QueryMXBean: Deprecated. Use managements API beans, instead.
QueryMXBeanImpl: QueryMXBean implementation.
QueryParserMetricsHolder: Metric holder for metrics of query parser.
QueryProperties: Additional properties to execute the query (Stored in `QueryContext`).
QueryPropertyAccessor: Way of accessing a property - either via field or getter and setter methods.
QueryReadOnlyMethodsAccessor: Accessor with getter only.
QueryRetryException: The exception is thrown if a query was cancelled or timed out while executing.
QueryRunningFuture: Query running future.
QuerySchema: Dynamic cache schema.
QuerySchemaPatch: Query schema patch which contains `SchemaAbstractOperation` operations for changing query entities.
QuerySqlField: Annotates fields for SQL queries.
QuerySqlField.Group: Describes group of index and position of field in this group.
QuerySqlFunction: Annotates public static methods in classes to be used in SQL queries as custom functions.
QuerySysIndexDescriptorImpl: Sys Indexes descriptor.
QueryTextField: Annotation for fields to be indexed for full text search using Lucene.
QueryTypeCandidate: Type candidate which possibly will be registered.
QueryTypeDescriptorImpl: Descriptor of type.
QueryTypeIdKey: Identifying TypeDescriptor by cache name and value class.
QueryTypeNameKey: Query type name key.
QueryUtils: Utility methods for queries.
QueryUtils.KeyOrValProperty: Property used for keyFieldName or valueFieldName
QueueItemKey
QueueView: Queue representation for a `SystemView`.
QueueViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
R1<E1,​R>: Defines `alias` for `IgniteReducer` by extending it.
R2<E1,​E2,​R>: Defines `alias` for `IgniteReducer2` by extending it.
R3<E1,​E2,​E3,​R>: Defines `alias` for `IgniteReducer3` by extending it.
Random2LruPageEvictionTracker
RandomAccessFileIO: File I/O implementation based on `FileChannel`.
RandomAccessFileIOFactory: File I/O factory which provides RandomAccessFileIO implementation of FileIO.
RandomLruPageEvictionTracker
RandomLruPageReplacementPolicy: Random-LRU page replacement policy implementation.
RandomLruPageReplacementPolicyFactory: `RandomLruPageReplacementPolicy` factory.
RangeIndexQueryCriterion: Range index criterion that applies to BPlusTree based indexes.
ReadableDistributedMetaStorage: API for distributed data storage.
ReaderArguments: Arguments required for adding near cache reader to entry.
ReadOnlyCollectionView<T>: Collection wrapper.
ReadOnlyCollectionView2X<T>: Collections wrapper.
ReadOnlyDynamicMBean: Base class for read only `DynamicMBean` implementations.
ReadOnlyMetastorage
ReadOnlyMetricManager: Read only metric manager.
ReadOnlyMetricRegistry: Read only metric registry.
ReadOnlySystemViewRegistry: Read only system view registry.
ReadRepairStrategy: Read repair strategies.
ReadWriteMetastorage
RebalanceReassignExchangeTask
RebuildIndexAction: Maintenance action that handles index rebuilding.
RebuildIndexWorkflowCallback: Workflow for the index rebuild maintenance task.
RecordDataSerializer: Interface to provide size, read and write operations with WAL records without any headers and meta information.
RecordDataV1Serializer: Record data V1 serializer.
RecordDataV1Serializer.EncryptedDataEntry: Represents encrypted Data Entry (`DataEntry.key`, `value`) pair.
RecordDataV2Serializer: Record data V2 serializer.
RecordIO: Internal interface to provide size, read and write operations of WAL records including record header and data.
RecordSerializer: Record serializer.
RecordSerializerFactory: Factory for creating `RecordSerializer`.
RecordSerializerFactoryImpl
RecordV1Serializer: Record V1 serializer.
RecordV2Serializer: Record V2 serializer.
RecoveryDebug
RecoveryLastReceivedMessage: Recovery acknowledgment message.
RecycleRecord: Recycle index page.
ReencryptionRateTask: View/change cache group re-encryption rate limit .
ReencryptionRateTask.ReencryptionRateJobResult
ReencryptionResumeTask: Resume re-encryption of the cache group.
ReencryptionStartRecord: Logical record to restart reencryption with the latest encryption key.
ReencryptionStatusTask: Get re-encryption status of the cache group.
ReencryptionStatusTask.ReencryptionStatusResult
ReencryptionSuspendTask: Suspend re-encryption of the cache group.
ReencryptionSuspendTask.ReencryptionSuspendResumeJobResult
ReencryptStateUtils
ReentrantLockView: `IgniteLock` representation for a `SystemView`.
ReentrantLockViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ReentrantReadWriteLockWithTracking: ReentrantReadWriteLock adapter with readLock tracking.
ReentrantReadWriteLockWithTracking.ReadLockWithTracking: Tracks long rlock holders.
ReflectiveDirectBufferCleaner: `DirectBufferCleaner` implementation based on `sun.misc.Cleaner` and `sun.nio.ch.DirectBuffer.cleaner()` method.
RegexpMetricFilter: Metric registry filter based on regular expression.
RemoveRecord: Remove.
RendezvousAffinityFunction: Affinity function for partitioned cache based on Highest Random Weight algorithm.
ReplaceCandidate: Replacement removal candidate.
ReplaceRecord<L>: Replace.
RequestEvent
RequestEventListener
RequestFailEvent
RequestStartEvent
RequestSuccessEvent
ReservationReason: Represent a reason by that a WAL history was bounded.
RestartProcessFailureHandler: This handler could be used only with ignite.
RestQueryRequest: Sql query request.
RestQueryRequest.QueryType: Supported query types.
RestUserActionRequest: User request.
RetrieveConflictPartitionValuesTask
RetrieveConflictPartitionValuesTask.RetrieveConflictValuesJob
ReuseBag: Reuse bag for free index pages.
ReuseList: Reuse list.
ReuseListImpl: Reuse list.
RobinHoodBackwardShiftHashMap: Loaded pages mapping to relative pointer based on Robin Hood hashing: backward shift deletion algorithm.
RollbackRecord: Rollback record.
RolloverType: Defines WAL logging type with regard to segment rollover.
RootPage
RotatedIdPartRecord: Rotated (when page has been recycled) id part delta record.
RoundRobinConnectionPolicy: Round robin connection policy.
RoundRobinLoadBalancingSpi: This SPI iterates through nodes in round-robin fashion and pick the next sequential node.
RoundRobinLoadBalancingSpiMBean: Management bean for `RoundRobinLoadBalancingSpi` SPI.
RowLinkIO
RowStore: Data store for H2 rows.
RunnableWrapperClosure: Closure that wraps given runnable.
RunnableX: Runnable that can throw checked exception.
RunningQueryManager: Keep information about all running queries.
RX1<E1,​R>: Defines `alias` for `IgniteReducerX` by extending it.
RX2<E1,​E2,​R>: Defines `alias` for `IgniteReducer2X` by extending it.
RX3<E1,​E2,​E3,​R>: Defines `alias` for `IgniteReducer3X` by extending it.
S: Defines internal `typedef` for `GridToStringBuilder`.
SameThreadExecutor
SandboxIgniteComponentProxy: Create instace of Ignite component proxy to use inside the Ignite Sandbox.
SB: Defines internal `typedef` for `GridStringBuilder`.
SBLimitedLength
ScannerHandler: Scanner handler which provide ability to do some handling on each record during iteration.
ScannerHandlers: Holder of `ScannerHandlers`.
ScanQuery<K,​V>: Scan query over cache entries.
ScanQueryCancelTask: Task to cancel scan queries.
ScanQueryIterator<K,​V,​R>
ScanQuerySystemView<K,​V>: `SystemView` implementation providing data about cache queries.
ScanQueryView: Scan query iterator representation for a `SystemView`.
ScanQueryViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
ScheduleIndexRebuildJobRes: Result of the ScheduleIndexRebuildJob.
ScheduleIndexRebuildTask: Task that schedules indexes rebuild for specified caches via the maintenance mode.
ScheduleIndexRebuildTaskRes: Result of the ScheduleIndexRebuildTask.
SchedulerFuture<R>: Future for cron-based scheduled execution.
SchemaAbstractAlterTableOperation: Parent class for ALTER TABLE command variants.
SchemaAbstractDiscoveryMessage: Abstract discovery message for schema operations.
SchemaAbstractOperation: Abstract operation on schema.
SchemaAddQueryEntityOperation: Enabling indexing on cache operation.
SchemaAlterTableAddColumnOperation: Schema index drop operation.
SchemaAlterTableDropColumnOperation: Schema alter table drop column operation.
SchemaChangeListener
SchemaDescriptor: Local database schema object.
SchemaExchangeWorkerTask: Cache schema change task for exchange worker.
SchemaFinishDiscoveryMessage: Schema change finish discovery message.
SchemaIndexAbstractOperation: Schema index abstract operation.
SchemaIndexCacheCompoundFuture: Compound index rebuilding feature.
SchemaIndexCacheFilter: Index row filter accepting current entry.
SchemaIndexCacheFuture: Extending `GridFutureAdapter` to rebuild indices.
SchemaIndexCachePartitionWorker: Worker for creating/rebuilding indexes for cache per partition.
SchemaIndexCacheStat: Class for accumulation of record types and number of indexed records in index tree.
SchemaIndexCacheVisitor: Closure that internally applies given `SchemaIndexCacheVisitorClosure` to some set of entries.
SchemaIndexCacheVisitorClosure: Index closure accepting current entry state.
SchemaIndexCacheVisitorImpl: Visitor who create/rebuild indexes in parallel by partition for a given cache.
SchemaIndexCreateOperation: Schema index create operation.
SchemaIndexDropOperation: Schema index drop operation.
SchemaIndexOperationCancellationException: Exception occurred when canceling index rebuild via `IndexRebuildCancelToken`.
SchemaManager: Local schema manager.
SchemaNodeLeaveExchangeWorkerTask: Node leave exchange worker task.
SchemaOperationClientFuture: Schema operation client future.
SchemaOperationException: Schema operation exception.
SchemaOperationManager: Schema operation manager.
SchemaOperationStatusMessage: Schema operation status message.
SchemaOperationWorker: Schema operation executor.
SchemaProposeDiscoveryMessage: Schema change propose discovery message.
SchemaSqlViewManager: Global schema SQL view manager.
SchemaVersionOne: A concrete `ISchemaVersion` representing schema version one.
Scope: Tracing span scope.
ScoredCacheEntry<K,​V>: Represents cache key-value pair and score to compare cache entry by custom rule.
SearchRow
SecurityAwareBiPredicate<E1,​E2>: Security aware IgniteBiPredicate.
SecurityAwareCustomMessageWrapper: Extends `CustomMessageWrapper` with ID of security subject that initiated the current message.
SecurityAwareFilter<K,​V>: Security aware remote filter.
SecurityAwareFilterFactory<K,​V>: Security aware remote filter factory.
SecurityAwareIoPool: Wrapper of `IoPool` that executes tasks in security context that was actual when task was added to pool queue.
SecurityAwarePredicate<E>: Security aware IgnitePredicate.
SecurityAwareStripedExecutor: Extends `StripedExecutor` with the ability to execute tasks in security context that was actual when task was added to executor's queue.
SecurityAwareStripedThreadPoolExecutor: Extends `IgniteStripedThreadPoolExecutor` with the ability to execute tasks in security context that was actual when task was added to executor's queue.
SecurityAwareThreadPoolExecutor: Extends `ThreadPoolExecutor` with the ability to execute tasks in security context that was actual when task was added to executor's queue.
SecurityAwareTransformerFactory<E,​R>: Security aware transformer factory.
SecurityBasicPermissionSet: Simple implementation of `SecurityPermissionSet` interface.
SecurityContext: This interface should be used to get security subject and perform checks for specific permissions.
SecurityCredentials: Security credentials used for node authentication.
SecurityCredentialsAttrFilterPredicate: Predicate to filter out security credentials attribute by its name.
SecurityCredentialsBasicProvider: Basic implementation for `SecurityCredentialsProvider`.
SecurityCredentialsProvider: Security credentials provider for specifying security credentials.
SecurityException: Common security exception for the grid.
SecurityPermission: Supported security permissions within grid.
SecurityPermissionSet: Security permission set for authorized security subjects.
SecurityPermissionSetBuilder: Provides a convenient way to create a permission set.
SecuritySubject: Security subject representing authenticated node with a set of permissions.
SecuritySubjectType: Supported security subject types.
SecurityUtils: Security utilities.
SegmentationPolicy: Policy that defines how node will react on topology segmentation.
SegmentationResolver: This is interface for segmentation (a.k.a "split-brain" problem) resolvers.
SegmentAware: Holder of actual information of latest manipulation on WAL segments.
SegmentedLruPageList: Pages Segmented-LRU (SLRU) list implementation.
SegmentedLruPageReplacementPolicy: Segmented-LRU page replacement policy implementation.
SegmentedLruPageReplacementPolicyFactory: `SegmentedLruPageReplacementPolicy` factory.
SegmentedRingByteBuffer: Segmented ring byte buffer that represents multi producer/single consumer queue that can be used by multiple writer threads and one reader thread.
SegmentedRingByteBuffer.BufferMode: Buffer mode.
SegmentEofException: This exception is thrown either when we reach the end of file of WAL segment, or when we encounter a record with type equal to `WALRecord.RecordType.STOP_ITERATION_RECORD_TYPE`
SegmentFileInputFactory: Factory to provide I/O interfaces for read primitives with files.
SegmentHeader: WAL segment header info.
SegmentIO: Implementation of `FileIO` specified for WAL segment file.
SegmentRouter: Class for manage of segment file location.
SemaphoreView: `IgniteSemaphore` representation for a `SystemView`.
SemaphoreViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SerializableTransient: Marks class as it has transient fields that should be serialized.
SerializationUtil: A collection of constants and utilities for serializing and deserializing HLLs.
SerializeSeparately: This annotation is needed to mark fields of `CacheConfiguration` to serialize them separately during sending over network or storing to disk.
Service: An instance of grid-managed service.
ServiceCallContext: Service call context.
ServiceCallContextBuilder: Service call context builder.
ServiceCallContextHolder: Holder of the context of the service call.
ServiceCallContextImpl: Service call context implementation.
ServiceCallInterceptor: Service call interceptor.
ServiceChangeBatchRequest: Service change batch request discovery message.
ServiceClusterDeploymentResult: Service cluster deployment result.
ServiceClusterDeploymentResultBatch: Batch of services cluster deployment result.
ServiceConfiguration: Managed service configuration.
ServiceContext: Service execution context.
ServiceContextImpl: Service context implementation.
ServiceContextResource: Annotates a field or a setter method for injecting a `service context` into a `service` instance.
ServiceDeploymentActions: Actions of change service state to be processed in the service deployment process.
ServiceDeploymentException: Exception indicating service deployment failure.
ServiceDeploymentManager: Service deployment manager.
ServiceDeploymentProcessId: Service deployment process' identifier.
ServiceDeploymentRequest: Service deployment request.
ServiceDescriptor: Service deployment descriptor.
ServiceInfo: Service's information container.
ServiceMXBean: Deprecated. Use managements API beans, instead.
ServiceMXBeanImpl: ServiceMXBean implementation.
ServiceProcessorJoinNodeDiscoveryData: Initial data of `IgniteServiceProcessor` to send in cluster on joining node.
ServiceResource: Annotates a field or a setter method for injection of Ignite service(s) by specified service name.
ServiceSingleNodeDeploymentResult: Service single node deployment result.
ServiceSingleNodeDeploymentResultBatch: Batch of service single node deployment result.
ServiceUndeploymentRequest: Service undeployment request.
ServiceView: Service representation for a `SystemView`.
ServiceViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SessionWriteRequest
SetFactoryCallable: Hash set factory.
SetItemKey
SetStateCommand
SetStateCommandArg
SetView: Set representation for a `SystemView`.
SetViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SharedFsCheckpointSpi: This class defines shared file system `CheckpointSpi` implementation for checkpoint SPI.
SharedFsCheckpointSpiMBean: Management bean that provides general administrative and configuration information about shared file system checkpoints.
SharedPageLockTracker
SharedPageLockTrackerDump
ShortIndexKey
ShortInlineIndexKeyType: Inline index key implementation for inlining `Short` values.
ShutdownPolicy: This class reperesents a policy of shutdown.
ShutdownPolicyCommand
ShutdownPolicyCommandArg
ShutdownPolicyTask: Shutdown policy task.
ShutdownPolicyTaskResult: Shutdown policy visor trsk result.
SignedBytesIndexKey
SignedBytesInlineIndexKeyType: Inline index key implementation for inlining byte arrays.
SimpleDataPageIO: Data pages IO for writing binary arrays.
SimpleDataRow: Implementation of `Storable` which holds byte array of variable length.
SimpleDistributedProperty<T extends Serializable>: Wrapper of some serializable property providing ability of change this value across whole cluster.
SimpleFileInput: File input, backed by byte buffer file input.
SimpleSegmentFileInputFactory: Simple implementation of `SegmentFileInputFactory`.
SingleCursor<T>: Cursor that holds single value only.
SingleNodeMessage<R extends Serializable>: Single node result message.
SingleSegmentLogicalRecordsIterator: Iterates over logical records of one WAL segment from archive.
SnapshotCancelCommand
SnapshotCancelCommandArg
SnapshotCancelTask
SnapshotCancelTask.CancelSnapshotArg
SnapshotCheckCommand
SnapshotCheckCommandArg
SnapshotCheckTask
SnapshotCommand: Snapshot commands.
SnapshotCreateCommand
SnapshotCreateCommandArg
SnapshotCreateTask
SnapshotDiscoveryMessage: Initial snapshot discovery message with possibility to trigger exchange.
SnapshotEvent: Event indicating the cluster snapshot operation result state with the given name.
SnapshotFilesFailureMessage: Message indicating a failure occurred during processing snapshot files request.
SnapshotFilesRequestMessage
SnapshotFinishedFutureTask
SnapshotFutureTaskResult: Represents result of `SnapshotFutureTask`.
SnapshotHandler<T>: Snapshot operation handler.
SnapshotHandlerContext: Snapshot operation handler context.
SnapshotHandlerRestoreTask: Snapshot restore operation handling task.
SnapshotHandlerResult<T>: Result of local processing on the node.
SnapshotHandlerType: Type of snapshot operation handler.
SnapshotJob<A,​R>
SnapshotMetadata: Snapshot metadata file.
SnapshotMetadataVerificationTask: Snapshot task to verify snapshot metadata on the baseline nodes for given snapshot name.
SnapshotMetadataVerificationTaskArg: Input parameters for checking snapshot metadata.
SnapshotMetadataVerificationTaskResult
SnapshotMXBean: Deprecated. Use managements API beans, instead.
SnapshotMXBeanImpl: Snapshot MBean features.
SnapshotOperation: Initial snapshot operation interface.
SnapshotOperationRequest: Snapshot operation start request for `DistributedProcess` initiate message.
SnapshotPartitionsQuickVerifyHandler: Quick partitions verifier.
SnapshotPartitionsVerifyHandler: Default snapshot restore handler for checking snapshot partitions consistency.
SnapshotPartitionsVerifyTask: Task for checking snapshot partitions consistency the same way as `VerifyBackupPartitionsTaskV2` does.
SnapshotPartitionsVerifyTaskArg: Input parameters for checking snapshot partitions consistency task.
SnapshotPartitionsVerifyTaskResult: The result of execution snapshot partitions verify task which besides calculating partition hashes of `IdleVerifyResultV2` also contains the snapshot metadata distribution across the cluster.
SnapshotRecord: Wal snapshot record.
SnapshotResponseRemoteFutureTask
SnapshotRestoreCommand
SnapshotRestoreCommandArg
SnapshotRestoreProcess: Distributed process to restore cache group from the snapshot.
SnapshotRestoreTask: Visor snapshot restore task.
SnapshotSender
SnapshotStatusCommand
SnapshotStatusTask: Task to get the status of the current snapshot operation in the cluster.
SnapshotStatusTask.SnapshotOperation: Snapshot operation type.
SnapshotStatusTask.SnapshotStatus: Snapshot operation status.
SnapshotView: Snapshot representation for a `SystemView`.
SnapshotViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SnapshotWarningException: Snapshot operation warning.
SocketMessageConverter<T>: Socket message converter.
SocketStreamer<T,​K,​V>: Server that receives data from TCP socket, converts it to key-value pairs using `StreamTupleExtractor` and streams into `IgniteDataStreamer` instance.
SortedEvictionPolicy<K,​V>: Cache eviction policy which will select the minimum cache entry for eviction.
SortedEvictionPolicyFactory<K,​V>: Factory class for `SortedEvictionPolicy`.
SortedEvictionPolicyMBean: MBean for sorted eviction policy.
SortedIndexDefinition: Represents a definition of a sorted index.
SortedIndexDescriptorFactory: Factory to create sorted index descriptors.
SortedSegmentedIndex: Interface for sorted and segmented Ignite indexes.
SortedSegmentedIndexCursor: Single cursor over multiple segments.
SortOrder: Enum of possible sort orders.
Span: Logical piece of a trace that represents a single operation.
SpanContainer: Container to store serialized span context and span that is created from this context.
SpanImpl: Implementation of a `Span`
SpanManager: Manager for `Span` instances.
SpanStatus: Various statuses for Spans execution.
SpanTags: List of tags that can be used to decorate spans.
SpanTransport: This interface indicates class which able to transfer span.
SpanType: List of span type names used in appropriate sub-systems.
SpiQuery<K,​V>: Deprecated. Use `ScanQuery`, `SqlFieldsQuery`, `IndexQuery` instead.
SpiSpecificSpan: Logical piece of a trace that insulates spi specific logic.
SplitExistingPageRecord: Split existing page.
SplitForwardPageRecord: Split forward page record.
SpringApplicationContextResource: Annotates a field or a setter method for injection of Spring ApplicationContext resource.
SpringResource: Annotates a field or a setter method for injection of resource from Spring `ApplicationContext`.
SpringResource.DEFAULT: Dummy class to compensate for impossibility of having default null value for annotation method.
SqlAlterTableCommand: ALTER TABLE command.
SqlAlterUserCommand: ALTER USER command.
SqlAnalyzeCommand: ANALYZE command to mark object for statistics collection.
SqlBulkLoadCommand: A parser for a COPY command (called 'bulk load' in the code, since word 'copy' is too generic).
SqlClientContext: Container for connection properties passed by various drivers (JDBC, ODBC drivers) having notion of an SQL connection - Ignite basically does not have one.
SqlCommand: Generic SQL command.
SqlCommandProcessor: Processor responsible for execution of native Ignite commands.
SqlConfiguration: The configuration of the SQL query subsystem.
SqlConnectorConfiguration: Deprecated.
SqlCreateIndexCommand: CREATE INDEX command.
SqlCreateUserCommand: CREATE USER command.
SqlCreateViewCommand: CREATE VIEW command.
SqlDropIndexCommand: DROP INDEX command.
SqlDropStatisticsCommand: DROP STATISTICS Command.
SqlDropUserCommand: DROP USER command.
SqlDropViewCommand: DROP VIEW command.
SqlFieldsQuery: SQL Fields query.
SqlFieldsQueryEx: `SqlFieldsQuery` with experimental and internal features.
SqlIndexColumn: Index column definition.
SqlIndexView: Sql index representation for a `SystemView`.
SqlIndexViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SqlInputStreamWrapper: InputStream wrapper used to pass it as argument to PreparedStatement.
SqlKeyword: SQL keyword constants.
SqlKillClientCommand: KILL CLIENT command.
SqlKillComputeTaskCommand: KILL COMPUTE_TASK command.
SqlKillContinuousQueryCommand: KILL CONTINUOUS command.
SqlKillQueryCommand: KILL QUERY command.
SqlKillScanQueryCommand: KILL SCAN_QUERY command.
SqlKillServiceCommand: KILL SERVICE command.
SqlKillTransactionCommand: KILL TRANSACTION command.
SqlLexer: SQL lexer.
SqlLexerLookAheadToken: Plain immutable look-ahead parser token.
SqlLexerToken: SQL parser token interface.
SqlLexerTokenType: Lexer token type.
SqlListenerDataTypes: Data type names usable in SQL queries after escape sequence transformation
SqlListenerUtils: Binary reader with marshaling non-primitive and non-embedded objects with JDK marshaller.
SqlParseException: Parse exception.
SqlParser: SQL parser.
SqlParserUtils: Parser utility methods.
SqlQualifiedName: SQL qualified name.
SqlQuery<K,​V>: Deprecated. Since 2.8, please use `SqlFieldsQuery` instead.
SqlQueryExecutionEvent: Query execution event.
SqlQueryHistoryView: SQL query history representation for a `SystemView`.
SqlQueryHistoryViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SqlQueryMXBean: Deprecated. Temporary monitoring solution.
SqlQueryMXBeanImpl: QueryMXBean implementation.
SqlQueryView: SQL query representation for a `SystemView`.
SqlQueryViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SqlRefreshStatitsicsCommand: REFRESH STATISTICS Command.
SqlSchemaView: Sql schema system view representation.
SqlSchemaViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SQLServerDialect: A dialect compatible with the Microsoft SQL Server database.
SqlSetStreamingCommand: SET STREAMING command.
SqlStateCode: SQL state codes.
SqlStatisticsCommands: Base class for statistics related commands.
SqlStrictParseException: Parse exception guarantees parse error without.
SqlTableColumnView: Sql table column representation for a `SystemView`.
SqlTableColumnViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SqlTableView: Sql table representation for a `SystemView`.
SqlTableViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SqlViewColumnView: Sql view column representation for a `SystemView`.
SqlViewColumnViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SqlViewView: Sql view representation for a `ViewDescriptor`.
SqlViewViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
SslContextFactory: SSL context factory that provides SSL context configuration with specified key and trust stores.
SSLContextWrapper: Wrapper for `SSLContext` that extend source context with custom SSL parameters.
SslMode: SSL/TLS modes.
SslProtocol: SSL Protocol.
StandaloneGridKernalContext: Dummy context for offline utilities.
StandaloneNoopCommunicationSpi: No-operation SPI for standalone WAL reader
StandaloneNoopDiscoverySpi: No-operation SPI for standalone WAL reader
StandaloneSpiContext: Dummy SPI context for offline utilities.
StartCacheInfo: Specific cache information for start.
StartNodeCallable: SSH-based node starter, returns tuple which contains hostname, success flag and error message if attempt was not successful.
StartRoutineAckDiscoveryMessage
StartRoutineDiscoveryMessage: Discovery message used for Continuous Query registration.
StartRoutineDiscoveryMessageV2
StateChangeRequest
StateCommand
StatisticsAddressedRequest: Statistics request with target/sender node id.
StatisticsColumnConfiguration: Describe configuration of the statistic for a database object' column.
StatisticsColumnConfigurationView: Statistics column configuration representation for a `SystemView`.
StatisticsColumnConfigurationViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
StatisticsColumnData: Statistics by column (or by set of columns, if they collected together)
StatisticsColumnGlobalDataView: Statistics global data view.
StatisticsColumnGlobalDataViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
StatisticsColumnLocalDataView: Statistics local data view.
StatisticsColumnLocalDataViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
StatisticsColumnOverrides: Configuration overrides.
StatisticsColumnPartitionDataView: Statistics partition data view.
StatisticsColumnPartitionDataViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
StatisticsDecimalMessage: H2 Decimal.
StatisticsKey: Key to collect statistics by.
StatisticsKeyMessage: Key, describing the object of statistics.
StatisticsObjectConfiguration: Describe configuration of the statistic for a database object (e.g.
StatisticsObjectConfiguration.Diff: Difference between current and target configuration.
StatisticsObjectData: Statistics for some object (index or table) in database.
StatisticsProcessor: Process all tasks, related to statistics repository.
StatisticsRequest: Request for statistics.
StatisticsResponse: Response for statistics request.
StatisticsTarget: Target to collect statistics by.
StatisticsType: Types of statistics width.
StatisticsUsageState: Statistics usage state.
StatisticsUtils: Utilities to convert statistics from/to messages, validate configurations with statistics and so on.
StopCachesOnClientReconnectExchangeTask
StopNodeFailureHandler: Handler will stop node in case of critical error using `IgnitionEx.stop(nodeName, true, true)` call.
StopNodeOrHaltFailureHandler: Handler will try to stop node if `tryStop` value is `true`.
StopRoutineAckDiscoveryMessage
StopRoutineDiscoveryMessage
Storable: Simple interface for data, store in some RowStore.
StorageException: Exception is needed to distinguish WAL manager & page store critical I/O errors.
StoredCacheData: Cache data to write to and read from `IgnitePageStoreManager`.
StreamAdapter<T,​K,​V>: Convenience adapter for streamers.
StreamMultipleTupleExtractor<T,​K,​V>: Stream tuple extractor to convert a single message to zero, one or many tuples.
StreamReceiver<K,​V>: Updates cache with batch of entries.
StreamSingleTupleExtractor<T,​K,​V>: Stream tuple extractor to convert a message to a single Ignite key-value tuple.
StreamTransformer<K,​V>: Convenience adapter to transform update existing values in streaming cache based on the previously cached value.
StreamTupleExtractor<T,​K,​V>: Deprecated. Will be removed in 2.0.0.
StreamVisitor<K,​V>: Convenience adapter to visit every key-value tuple in the stream.
StrictBoundsCheckException: This exception is used in checking boundaries (StandaloneWalRecordsIterator).
StringConcatReducer: Reducer that concatenates strings using provided delimiter.
StringIndexKey
StringInlineIndexKeyType: Inline index key implementation for inlining `String` values.
StringNoCompareInlineIndexKeyType: Skip optimized String comparison implemented in `StringInlineIndexKeyType`.
StripedCompositeReadWriteLock: ReadWriteLock with striping mechanics.
StripedExecutor: Striped executor.
StripedExecutor.Stripe: Stripe.
StripedExecutorTaskView: `StripedExecutor` task representation for a `SystemView`.
StripedExecutorTaskViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
StrListAppenderBlock: The PipelineBlock which appends its input to a user-supplied list.
SupplyPartitionInfo: Information about supplier for specific partition.
SwitchSegmentRecord: Record is needed to mark end of segment.
SystemDataRegionConfiguration: This class allows defining system data region configuration with various parameters for Apache Ignite page memory (see `DataStorageConfiguration`.
SystemProperty: Ignite system property info.
SystemView<R>: Implementation provides data for some internal Ignite objects.
SystemViewAdapter<R,​D>: System view backed by `data` `Collection`.
SystemViewCommand: Command for printing system view content.
SystemViewCommandArg
SystemViewExporterSpi: Exporter of system view to the external recepient.
SystemViewInnerCollectionsAdapter<C,​R,​D>: System view backed by `data` container.
SystemViewMBean<R>: JMX bean to expose specific `SystemView` data.
SystemViewRowAttributeWalker<R>: Utility class for quick iteration over row properties.
SystemViewRowAttributeWalker.AttributeVisitor: Attribute visitor.
SystemViewRowAttributeWalker.AttributeWithValueVisitor: Attribute visitor.
SystemViewTask: Reperesents visor task for obtaining system view content.
SystemViewTask.SimpleType: Represents lightweight type descriptors.
SystemViewTaskResult: Reperesents result of `SystemViewTask`.
T1<V>: Defines `alias` for `GridTuple` by extending it.
T2<V1,​V2>: Defines `alias` for `IgniteBiTuple` by extending it.
T3<V1,​V2,​V3>: Defines `alias` for `GridTuple3` by extending it.
T4<V1,​V2,​V3,​V4>: Defines `alias` for `GridTuple4` by extending it.
T5<V1,​V2,​V3,​V4,​V5>: Defines `alias` for `GridTuple5` by extending it.
T6<V1,​V2,​V3,​V4,​V5,​V6>: Defines `alias` for `GridTuple6` by extending it.
TableCacheScanTaskFormat: This format prints cache objects fields in table format.
TableDescriptor: Local database table object.
TableInformation: Information about table.
TaskContinuousMapperResource: Annotates a field or a setter method for injection of `ComputeTaskContinuousMapper` resource.
TaskEvent: Grid task event.
TaskExecutionOptions
TaskSessionResource: Annotates a field or a setter method for injection of `ComputeTaskSession` resource.
TCKMBeanServerBuilder: This class is needed for JCache TCK tests.
TcpClientCache<K,​V>: Implementation of `ClientCache` over TCP protocol.
TcpCommunicationConfigInitializer: Only may implement it TcpCommunicationSpi.
TcpCommunicationConfiguration: Class of configuration for `TcpCommunicationSpi` segregation.
TcpCommunicationConnectionCheckFuture: Tcp Communication Connection Check Future.
TcpCommunicationMetricsListener: Statistics for `TcpCommunicationSpi`.
TcpCommunicationNodeConnectionCheckFuture: Tcp Communication Node Connection Check Future.
TcpCommunicationSpi: `TcpCommunicationSpi` is default communication SPI which uses TCP/IP protocol and Java NIO to communicate with other nodes.
TcpCommunicationSpiMBean: MBean provide access to TCP-based communication SPI.
TcpCommunicationSpiMBeanImpl: MBean implementation for TcpCommunicationSpi.
TcpConnectionIndexAwareMessage
TcpConnectionRequestDiscoveryMessage: Message is part of communication via discovery protocol.
TcpDiscoveryAbstractMessage: Base class to implement discovery messages.
TcpDiscoveryAbstractTraceableMessage: Abstract traceable message for TCP discovery.
TcpDiscoveryAuthFailedMessage: Message telling joining node that its authentication failed on coordinator.
TcpDiscoveryCheckFailedMessage: Message telling joining node that it failed coordinator's validation check.
TcpDiscoveryClientAckResponse
TcpDiscoveryClientMetricsUpdateMessage: Metrics update message.
TcpDiscoveryClientPingRequest: Ping request.
TcpDiscoveryClientPingResponse: Ping request.
TcpDiscoveryClientReconnectMessage: Message telling that client node is reconnecting to topology.
TcpDiscoveryConnectionCheckMessage: Message used to check whether a node is still connected to the topology.
TcpDiscoveryCustomEventMessage: Wrapped for custom message.
TcpDiscoveryDiscardMessage: Message sent by coordinator when some operation handling is over.
TcpDiscoveryDummyWakeupMessage
TcpDiscoveryDuplicateIdMessage: Message telling joining node that new topology already contain different node with same ID.
TcpDiscoveryEnsureDelivery: Message classes with this annotation attached are processed in a special way to ensure messages delivery.
TcpDiscoveryHandshakeRequest: Handshake request.
TcpDiscoveryHandshakeResponse: Handshake response.
TcpDiscoveryIpFinder: IP finder interface for `TcpDiscoverySpi`.
TcpDiscoveryIpFinderAdapter: IP finder interface implementation adapter.
TcpDiscoveryJdbcIpFinder: JDBC-based IP finder.
TcpDiscoveryJoinRequestMessage: Initial message sent by a node that wants to enter topology.
TcpDiscoveryLoopbackProblemMessage: Message telling joining node that it has loopback problem (misconfiguration).
TcpDiscoveryMetricsUpdateMessage: Metrics update message.
TcpDiscoveryMetricsUpdateMessage.MetricsSet
TcpDiscoveryMulticastIpFinder: Multicast-based IP finder.
TcpDiscoveryNode: Node for `TcpDiscoverySpi`.
TcpDiscoveryNodeAddedMessage: Message telling nodes that new node should be added to topology.
TcpDiscoveryNodeAddFinishedMessage: Sent by coordinator across the ring to finish node add process.
TcpDiscoveryNodeFailedMessage: Sent by node that has detected node failure to coordinator across the ring, then sent by coordinator across the ring.
TcpDiscoveryNodeLeftMessage: Sent by node that is stopping to coordinator across the ring, then sent by coordinator across the ring.
TcpDiscoveryNodesRing: Convenient way to represent topology for `TcpDiscoverySpi`
TcpDiscoveryPingRequest: Ping request.
TcpDiscoveryPingResponse: Ping response.
TcpDiscoveryRedirectToClient: Message classes with this annotation attached will be redirected to client nodes when going through ring.
TcpDiscoveryRingLatencyCheckMessage
TcpDiscoveryServerOnlyCustomEventMessage: Wrapped for custom message that must not be delivered to the client nodes.
TcpDiscoverySharedFsIpFinder: Shared filesystem-based IP finder.
TcpDiscoverySpi: Discovery SPI implementation that uses TCP/IP for node discovery.
TcpDiscoverySpiMBean: Management bean for `TcpDiscoverySpi`.
TcpDiscoverySpiState: State of local node `TcpDiscoverySpi`.
TcpDiscoveryStatistics: Statistics for `TcpDiscoverySpi`.
TcpDiscoveryStatusCheckMessage: Message sent by node to its next to ensure that next node and connection to it are alive.
TcpDiscoveryVmIpFinder: IP Finder which works only with pre-configured list of IP addresses specified via `TcpDiscoveryVmIpFinder.setAddresses(Collection)` method.
TcpHandshakeExecutor: Executor for synchronously establishing a connection with a node.
TcpIgniteClient: Implementation of `IgniteClient` over TCP protocol.
TcpInverseConnectionResponseMessage: Inverse connection response message sent by client node as a response to inverse connection request received by discovery.
TextQuery<K,​V>: Full Text Queries
TextQueryReducer<R>: Reducer for `TextQuery` results.
ThinClientConfiguration: Server-side thin-client configuration.
ThinProtocolFeature: The base feature class.
ThreadLocalDirectByteBuffer: Thread local direct byte buffer.
ThreadLocalRowHandlerHolder: Holds an index row handler during work session with an index tree.
ThreadPageLockState
ThrowableBiFunction<T,​U,​R,​E extends Throwable>: Specific interface for transmitting exceptions from lambda to external method without a catch.
ThrowableFunction<R,​T,​E extends Exception>: Specific interface for transmitting exceptions from lambda to external method without a catch.
ThrowableSupplier<T,​E extends Throwable>: Specific interface for transmitting exceptions from lambda to external method without a catch.
TimeBag: Utility class to measure and collect timings of some execution workflow.
TimeIndexKey
TimeInlineIndexKeyType: Inline index key implementation for inlining `TimeIndexKey` values.
TimeoutStrategy: Strategy to calculate next timeout and check if total timeout reached.
TimestampIndexKey
TimestampInlineIndexKeyType: Inline index key implementation for inlining `TimestampIndexKey` values.
TimeStampRecord: Base class for records with timeStamp.
ToFileDumpProcessor
TopologyValidator: Topology validator is used to verify that cluster topology is valid for further cache operations.
ToStringClosure<T>: Closure that return `toString()` value for its free variable.
ToStringDumpHelper: Helper for creating string from `PageLockDump`.
TraceableIterator<T>: Represents wrapper which allows the iterator methods to execute within context of a specified span.
TraceableMessage: Interface for messages that contain trace context for an operation.
TraceableMessagesHandler: Helper to handle traceable messages.
TraceableMessagesTable: Mapping from traceable message to appropriate trace.
TraceRunnable: Wrapper of `Runnable` which incject tracing to execution.
Tracing: Tracing sub-system interface.
TracingConfigurationCommand
TracingConfigurationCommand.TracingConfigurationCommandArg
TracingConfigurationCommand.TracingConfigurationResetAllCommandArg
TracingConfigurationCommand.TracingConfigurationResetCommandArg
TracingConfigurationCoordinates: Specifies to which traces, specific configuration will be applied.
TracingConfigurationCoordinates.Builder: `TracingConfigurationCoordinates` builder.
TracingConfigurationGetAllCommand
TracingConfigurationGetAllCommandArg
TracingConfigurationGetCommand
TracingConfigurationGetCommandArg
TracingConfigurationItem: Data transfer object that contains scope, label, sampling rate and set of included scopes.
TracingConfigurationManager: Allows to configure tracing, read the configuration and restore it to the defaults.
TracingConfigurationParameters: Set of tracing configuration parameters like sampling rate or included scopes.
TracingConfigurationParameters.Builder: `TracingConfigurationParameters` builder.
TracingConfigurationResetAllCommand
TracingConfigurationResetCommand
TracingConfigurationSetCommand
TracingConfigurationSetCommandArg
TracingConfigurationTask: Task that will collect and update tracing configuration.
TracingConfigurationTaskResult: Result for `TracingConfigurationTask`.
TracingSpi<S extends SpiSpecificSpan>: Tracing SPI interface.
TracingSpiType: Type of the tracing spi.
TrackableQuery: Query, that can be tracked by `HeavyQueriesTracker`.
TrackingPageDeltaRecord: Delta record for updates in tracking pages
TrackingPageIO: We use dedicated page for tracking pages updates.
TrackingPageIsCorruptedException: Thrown when corrupted tracking page was queried.
TrackingPageRepairDeltaRecord: Record that indicates that "corrupted" flag should be removed from tracking page.
Transaction: Ignite cache transaction.
TransactionChanges<E>: Changes of transaction in convenient for queries form.
TransactionCheckedException: Internal transaction exceptions base.
TransactionConcurrency: Transaction concurrency control.
TransactionConfiguration: Transactions configuration.
TransactionDeadlockException: Transaction deadlock exception.
TransactionEventProxyImpl: Transaction proxy used at tx events.
TransactionException: Base class for all transaction related exceptions.
TransactionHeuristicException: Exception thrown whenever grid transaction enters an unknown state.
TransactionIsolation: Defines different cache transaction isolation levels.
TransactionMetrics: Transaction metrics, shared across all caches.
TransactionMetricsAdapter: Tx metrics adapter.
TransactionMetricsAdapter.TransactionMetricsSnapshot: Transaction metrics snapshot.
TransactionMetricsMxBean: Deprecated. Check the `JmxMetricExporterSpi` with "name=\"tx\"" instead.
TransactionMetricsMxBeanImpl: Deprecated. Check the `JmxMetricExporterSpi` with "name=\"tx\"" instead.
TransactionOptimisticException: Exception thrown whenever grid transactions fail optimistically.
TransactionProxy: Marker interface for transaction proxy.
TransactionProxyImpl<K,​V>: Cache transaction proxy.
TransactionProxyRollbackOnlyImpl<K,​V>: Cache transaction proxy which supports only rollback or close operations and getters.
TransactionRollbackException: Exception thrown whenever grid transactions has been automatically rolled back.
TransactionsHashRecord: Represents committed transactions hash for a pair of nodes.
TransactionsMXBean: Transactions MXBean interface.
TransactionsMXBeanImpl: TransactionsMXBean implementation.
TransactionState: Cache transaction state.
TransactionStateChangedEvent: Event indicates transaction state change.
TransactionTimeoutException: Exception thrown whenever transactions time out.
TransactionView: Transaction representation for a `SystemView`.
TransactionViewWalker: Generated by `org.apache.ignite.codegen.SystemViewRowAttributeWalkerGenerator`.
TransformCollectionView<T1,​T2>: Light-weight view on given collection with provided predicate.
TransformFilteringIterator<T2,​T1>: Iterator from given iter and optional filtering predicate.
TransformMapView<K,​V1,​V>: Light-weight view on given map with provided predicate and clos.
TransformMapView2<K,​V,​V1>: Light-weight view on given map with provided predicate and clos.
TransientSerializable: Marks class as it has non-transient fields that should not be serialized.
TransmissionCancelledException: Exception is used to cancel a file transmission operation on the receiver.
TransmissionHandler: Class represents a handler for the set of files considered to be transferred from the remote node.
TransmissionMeta: Class represents a file meta information to send to the remote node.
TransmissionPolicy: Class represents ways of data handling for a file ready to be sent through an opened transmission sender session.
TreeIterator
TxCollisionsDumpSettingsClosure: Change tx collisions interval or negative for disabling.
TxCommand
TxCommand.AbstractTxCommandArg
TxCommandArg
TxCounters: Values which should be tracked during transaction execution and applied on commit.
TxDeadlock: Information about found deadlock.
TxDeadlockDetection: Transactions deadlock detection.
TxEntryValueHolder: Auxiliary class to hold value, value-has-been-set flag, value update operation, value bytes.
TxInfo
TxInfoCommand
TxInfoCommandArg
TxKeyLockType: Describes transaction key lock ownership type.
TxLock: Corresponds to one `GridCacheMvccCandidate` from local MVCC candidates queue.
TxLockList: List of transaction locks for particular key.
TxLocksRequest: Transactions lock list request.
TxLocksResponse: Transactions lock list response.
TxMappingType: Describes transaction mapping type.
TxRecord: Logical data record indented for transaction (tx) related actions. This record is marker of begin, prepare, commit, and rollback transactions.
TxRecordSerializer: `TxRecord` WAL serializer.
TxSortOrder
TxTask
TxTask.TxJob
TxTaskResult: Result for `TxTask`.
TxTimeoutOnPartitionMapExchangeChangeMessage: Discovery message for changing transaction timeout on partition map exchange.
TxTimeoutOnPartitionMapExchangeChangeTask: The task for changing transaction timeout on partition map exchange.
TxVerboseInfo: Encapsulates all verbose info about transaction needed for --tx --info output.
TxVerboseKey: Encapsulates info about transaction key and its lock ownership for --tx --info output.
TypeMapping: Ignite maps type name to some id.
TypeMappingImpl
U: Defines internal `typedef` for `IgniteUtils`.
UnregisteredBinaryTypeException: Exception thrown during serialization if binary metadata isn't registered and it's registration isn't allowed.
UnregisteredClassException: Exception thrown during serialization if class isn't registered and it's registration isn't allowed.
UnsafeChunk
UnsafeDirectBufferCleaner: `DirectBufferCleaner` implementation based on `Unsafe.invokeCleaner` method.
UnsafeMemoryAllocator
UnsafeMemoryProvider: Memory provider implementation based on unsafe memory access.
UnsortedCacheQueryReducer<R>: Reducer of cache query results, no ordering of results is provided.
UnwrapDataEntry: Data Entry for automatic unwrapping key and value from Data Entry
UnzipFileIO: `FileIO` that allows to work with ZIP compressed file.
UnzipFileIOFactory: File I/O factory which provides `UnzipFileIO` implementation of FileIO.
UpdateErrors
UpgradePendingTreeToPerPartitionTask: Ignite native persistence migration task upgrades existed PendingTrees to per-partition basis.
User
UserAcceptedMessage: Is sent as an acknowledgement for end (with success or error) of user management operation on the cluster (see `UserProposedMessage` and `UserManagementOperation`).
UserActionCommandHandler: User actions handler.
UserAuthenticateRequestMessage: Message is sent from client to coordinator node when a user needs to authorize on client node.
UserAuthenticateResponseMessage: Is sent from coordinator node to client to deliver the results of the user authentication.
UserCacheObjectByteArrayImpl: Wraps value provided by user, must be copied before stored in cache.
UserCacheObjectImpl: Wraps value provided by user, must be serialized before stored in cache.
UserKeyCacheObjectImpl: Wraps key provided by user, must be serialized before stored in cache.
UserManagementException: Exception that represents failures of user management operations.
UserManagementOperation: The operation with users.
UserManagementOperation.OperationType: User action type.
UserManagementOperationFinishedMessage: Message indicating that user operation is finished locally on the node.
UserProposedMessage: A node sends this message when it wants to propose user operation (add / update / remove).
UUIDCollectionMessage: Collection of UUIDs.
UuidIndexKey
UuidInlineIndexKeyType: Inline index key implementation for inlining `UUID` values.
ValidateIndexesCheckSizeIssue: Issue when checking size of cache and index.
ValidateIndexesCheckSizeResult: Result of checking size cache and index.
ValidateIndexesClosure: Closure that locally validates indexes of given caches.
ValidateIndexesContext: Validate indexes context.
ValidateIndexesJobResult
ValidateIndexesPartitionResult: Encapsulates intermediate results of validation of SQL index.
ValidateIndexesTask
ValidateIndexesTaskResult
ValidateIndexesTaskResult.NodeInfo: Holds node id and consistent id.
ValidationOnNodeJoinUtils: Util class for joining node validation.
VerifyBackupPartitionsDumpTask: Task for collection checksums primary and backup partitions of specified caches.
VerifyBackupPartitionsTaskV2: Task for comparing update counters and checksums between primary and backup partitions of specified caches.
ViewCacheClosure: View cache closure.
ViewCacheCmd
ViewCacheTask
ViewCacheTaskResult
ViewDescriptor: Local database view object.
VisorBaselineViewTask: Task that will collect information about baseline topology.
VisorClusterGroupEmptyException: Exception to throw from Visor tasks in case of empty topology.
VisorComputeCancelSessionsTask: Cancels given task session.
VisorComputeCancelSessionsTaskArg: Arguments for task `VisorComputeCancelSessionsTask`
VisorDataTransferObject: Deprecated. Use `IgniteDataTransferObject` instead.
VisorDataTransferObjectInput: Deprecated. Use `IgniteDataTransferObjectInput` instead.
VisorDataTransferObjectOutput: Deprecated. Use `IgniteDataTransferObjectOutput` instead.
VisorExceptionWrapper: Exception wrapper for safe for transferring to Visor.
VisorIdAndTagViewTask
VisorIdAndTagViewTaskResult
VisorJob<A,​R>: Base class for Visor jobs.
VisorMultiNodeTask<A,​R,​J>: Base class for Visor tasks intended to query data from a multiple node.
VisorOneNodeTask<A,​R>: Base class for Visor tasks intended to query data from a single node.
VisorTaskArgument<A>: Visor tasks argument.
VisorTaskResult<R>: Management task result.
VisorTaskUtils: Contains utility methods for Visor tasks and jobs.
VisorTaskUtils.SortableAddress: Special wrapper over address that can be sorted in following order: IPv4, private IPv4, IPv4 local host, IPv6.
VolatileAtomicDataStructureValue
WalCommand
WalDeleteCommand
WalDeleteCommandArg
WalFilters: Class for holding only very basic WAL filters for using in `FilteredWalIterator`.
WALIterator
WALMode: WAL Mode.
WALPointer: File WAL pointer.
WalPrintCommand
WalPrintCommand.WalPrintCommandArg
WALRecord: Log entry abstract class.
WALRecord.RecordPurpose: Record purposes set.
WALRecord.RecordType: Record type.
WalRecordCacheGroupAware: WAL record related to specific cache group.
WalRecordsConsumer<K,​V>: Transform `DataEntry` to `CdcEvent` and sends it to `CdcConsumer`.
WalRecordsConsumer.DataEntryIterator: Iterator over `DataEntry`.
WalScanner: Scanning WAL by specific condition.
WalScanner.ScanTerminateStep: Terminate state of scanning of WAL for ability to do chaining flow.
WalSegmentArchivedEvent: Event indicates the completion of WAL segment file transition to archive.
WalSegmentCompactedEvent: Event indicates the completion of WAL segment compaction.
WalSegmentTailReachedException: An exception is thrown when we reached tail of WAL segment cyclic buffer during reading from WAL.
WalStateAbstractMessage: WAL state change abstract message.
WalStateAckMessage: WAL state ack message (sent from participant node to coordinator).
WalStateDistributedProcess: Distributed process governing WAL state change.
WalStateFinishMessage: WAL state finish message.
WalStateManager: Write-ahead log state manager.
WalStateManager.WALDisableContext: Temporary storage for disabled WALs of group.
WalStateNodeLeaveExchangeTask: Exchange task to handle node leave for WAL state manager.
WalStateProposeMessage: WAL state propose message.
WalStateResult: Local WAL state change result.
WalTask: Performs WAL cleanup clusterwide.
WalTaskResult: Result of `WalTask`.
WarmUpCommand: Warm-up command.
WarmUpConfiguration: Warm-up configuration marker interface.
WarmUpMXBean: Deprecated. Use managements API beans, instead.
WarmUpMXBeanImpl: `WarmUpMXBean` implementation.
WarmUpStopCommand
WarmUpStrategy<T extends WarmUpConfiguration>: Interface for warming up.
WarmUpStrategySupplier: Interface for getting warm-up strategies from plugins.
WebSessionAttributeProcessor: Updates web session attributes according to `WebSessionAttributeProcessor.updatesMap` and `WebSessionAttributeProcessor.accessTime`, `WebSessionAttributeProcessor.maxInactiveInterval`.
WebSessionEntity: Entity
WeightedRandomLoadBalancingSpi: Load balancing SPI that picks a random node for job execution.
WeightedRandomLoadBalancingSpiMBean: Management MBean for `WeightedRandomLoadBalancingSpi` SPI.
WorkersControlMXBean: MBean that provides ability to terminate worker that registered in the workers registry.
WorkersControlMXBeanImpl: MBean that provides control of system workersRegistry.
WorkersRegistry: Workers registry.
WorkProgressDispatcher: Dispatcher of workers' progress which allows us to understand if worker freezes.
WriteOnlyZipFileIO: `FileIO` that allows to write ZIP compressed file.
WriteOnlyZipFileIOFactory: File I/O factory which provides `WriteOnlyZipFileIO` implementation of FileIO.
X: Defines global scope.