|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
CacheLoader that holds common implementations for some methodsCacheStore that holds common implementations for some methodsAbstractCacheStore.CustomFailurePolicy.AbstractDelegatingCache, but for AdvancedCache.AdvancedExternalizer implementations that offers default
implementations for some of its methods.CacheManagerNotifierImpl and
CacheNotifierImplLoaderConfigurationChildBuilder methods to a specified CacheLoaderConfigurationBuilderLockSupportStoreConfigurationChildBuilder methods
to a specified LockSupportStoreConfigurationBuilderModuleLifecycle interface, designed for easy
extension.AbstractConfigurationBean
.StoreConfigurationChildBuilder methods to a specified CacheStoreConfigurationBuilderGlobalTransactionTxInvocationContext.LockManager.acquireLock(org.infinispan.context.InvocationContext, Object, long, boolean), but doesn't check whether the
lock is already acquired by the caller.
SegmentReadLocker.deleteOrReleaseReadLock(String)
from deleting the file.
SegmentReadLocker.deleteOrReleaseReadLock(String)
from deleting the file.
ForkJoinTask that performs the run
method of the given Runnable as its action, and returns
a null result upon ForkJoinTask.join().
ForkJoinTask that performs the run
method of the given Runnable as its action, and returns
the given result upon ForkJoinTask.join().
ForkJoinTask that performs the call
method of the given Callable as its action, and returns
its result upon ForkJoinTask.join(), translating any checked exceptions
encountered into RuntimeException.
BufferSizePredictor that automatically increases and
decreases the predicted buffer size on feed back.AdvancedExternalizer with the give id.
AdvancedExternalizer.
AdvancedExternalizer implementation
alongside its corresponding identifier.
AdvancedExternalizer implementations.
AdvancedExternalizer
implementation alongside its corresponding identifier.
AdvancedExternalizer
implementation alongside its corresponding identifier.
AdvancedExternalizer
implementations.
CacheLoaderManagerConfig.addCacheLoader(org.infinispan.loaders.CacheLoaderConfig...) instead
Fqn under the current node.
Cache.Cache and AdvancedCache.AdvancedExternalizer provides an alternative way to provide
externalizers for marshalling/unmarshalling user defined classes that
overcome the deficiencies of the more user-friendly externalizer definition
model explained in Externalizer.mods atomically by creating a worker and invoking
them in TransactionRunner.run(com.sleepycat.collections.TransactionWorker).
null.
null.
Set with the given elements.
AtomicMap.AtomicHashMap to provide consistency and isolation for concurrent readers
while writes may also be going on.HBaseCacheStore configurationterminate().
true, this will cause the first call to method CacheManager.getCache() on the joiner node to
block and wait until the joining is complete and the cache has finished receiving state from neighboring caches
(if fetchInMemoryState is enabled).
true, this will cause the first call to method CacheManager.getCache() on the joiner node to
block and wait until the joining is complete and the cache has finished receiving state from neighboring caches
(if fetchInMemoryState is enabled).
ForkJoinTask.helpQuiesce().
BackupReceivers within this CacheManager.Base64.InputStream will read data from another
java.io.InputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.Base64.InputStream in DECODE mode.
Base64.InputStream in
either ENCODE or DECODE mode.
Base64.OutputStream will write data to another
java.io.OutputStream, given in the constructor,
and encode/decode to/from Base64 notation on the fly.Base64.OutputStream in ENCODE mode.
Base64.OutputStream in
either ENCODE or DECODE mode.
AdvancedCache.addInterceptor(CommandInterceptor, int) method (or any of its
overloaded forms) or registering custom interceptors via XML should extend this base class when creating their own
custom interceptors.InfinispanDirectory,
this factory produces instances of BaseLuceneLock.BasicCache.Log instances.Cache.startBatch() and
Cache.endBatch(boolean) calls.CacheStore.BdbjeCacheStore.BlockingRunnable and only dispatch the runnable to a thread when it has low
(or no) probability of blocking the thread.BlockingRunnable.Executors except that the factory methods here allow you to specify the
size of the blocking queue that backs the executor.RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
CacheStoreConfig level.
#buildCreateCacheCommand(String, String, false).
Metadata.Builder which can be used to build
new instances of Metadata instance which are full copies of
this Metadata.
GetInDoubtTransactionsCommand.
CommandsFactory.buildLockControlCommand(Object, java.util.Set, org.infinispan.transaction.xa.GlobalTransaction)
but for locking a single key vs a collection of keys.
TxCompletionNotificationCommand.
ByteArrayEquivalence in the context of the Equivalence APIAnnotationProvider implementation.CacheEntriesEvicted.CacheEntryActivated.CacheEntryCreated.CacheLoader.CacheEntryLoaded.CacheEntryModified
The CacheEntryModifiedEvent.getValue() method's behavior is specific to whether the callback is triggered before or after the event
in question.CacheEntryPassivated.CacheEntryRemoved.CacheEntryVisited.Cache fail unexpectedly.CacheContainer.getCache() methods and has not yet been removed via
EmbeddedCacheManager.removeCache(String).
CacheInvocationParameter implementation.Configuration.jmxStatistics() is enabled, then class will register all
the MBeans from cache local's ConfigurationRegistry to the MBean server.CacheKeyInvocationContext implementation.CacheLoader implementation if there are problems reading from a loader.CachePut interceptor implementation.SearchManagerImpl.CacheRemoveAll interceptor implementation.CacheRemoveEntry interceptor implementation.This interceptor uses the following algorithm describes in
JSR-107.CacheResult interceptor implementation.RpcManager only replicates commands wrapped in a CacheRpcCommand.CacheStarted.CacheStopped.CacheLoader interface that can be written to.LocalTopologyManager and StateTransferManager.Callable for the DistributedTask
CancellationServiceCacheLoader based on Apache Cassandra project.CassandraCacheStore.chunkSize cache entries.
chunkSize cache entries.
Listenable with the possibility of specifying the
ClassLoader which should be set as the context class loader for the invoked
listener methodCacheStore.clear() modificationMap.clear().
CloudCacheStore.ClusterCacheLoader.ClusteredGetCommands.ClusterTopologyManager implementation.MapperReplicableCommands.Visitor interface allowing it to
intercept invocations on VisitableCommands.DeltaAware.delta()) and can be
discarded.
TransactionXaAdapter.prepare(javax.transaction.xa.Xid) applies for commit.
FqnComparator.
CountedCompleter.onCompletion(org.infinispan.util.concurrent.jdk8backported.CountedCompleter),
marks this task as complete and further triggers CountedCompleter.tryComplete() on this task's completer, if one exists.
join and related operations.
join and related operations.
tx.
Scope, SurvivesRestarts,
DefaultFactoryFor, ComponentName, Inject, Start and Stop annotations.InjectStart or @Stopnull if there is no current
mapping).
RecoveryAwareRemoteTransaction.isOrphan().
ConcurrentHashMap to deal with the fact that the
JDK does not have a proper concurrent Set implementation that uses efficient lock striping.ConcurrentMap which is similar to ConcurrentHashMap.Configuration instead.Configuration and creates
equivalent instance of ConfigurationConfiguration objects to pass to the
RemoteCacheManager.RemoteCacheManager(Configuration) constructor.ConfigurationConfigurations.Configuration.cacheName has finished receiving the new data for topology
topologyId.
ConnectionFactory to handle connection to the database
ConnectionFactory.HashConfiguration.consistentHashFactory().
HashConfigurationBuilder.consistentHashFactory(ConsistentHashFactory).
HashConfigurationBuilder.consistentHashFactory(org.infinispan.distribution.ch.ConsistentHashFactory) instead.
ConsistentHash function.ConsistentHash instances.ConsistentHash implementation to use for the specified version.
ConsistentHash implementation to use for the specified version.
MurmurHash2;FactoryBean for creating a CacheManager for a pre-defined CacheContainer.true if this set contains the specified element.
CacheLoader.load(Object), to ensure that a response is
returned only if the entry is not expired.
true if this map maps one or more keys to the
specified value.
Input cache to be injected into Callables from
DistributedExecutorService and Mapper from MapReduceTask using CDI
mechanism.ForkJoinTask with a completion action performed when
triggered and there are no remaining pending
actions.InternalCacheEntry instance based on the key, value, version and timestamp/lifespan
information reflected in the CacheEntry instance passed in.
InternalCacheEntry instance based on the version and timestamp/lifespan
information reflected in the CacheEntry instance passed in.
InternalCacheEntry instance
InternalCacheEntry instance
InternalCacheEntry instance
InternalCacheEntry instance
AnnotatedType.
JdbmCacheStoreConfig.setComparatorClassName(String).
TxInvocationContext.
NonTxInvocationContext with the NonTxInvocationContext.isOriginLocal() returning true.
NonTxInvocationContext whose NonTxInvocationContext.isOriginLocal() flag will be true.
InvocationContextContainer.createRemoteInvocationContext(org.infinispan.remoting.transport.Address),
but returning the flags to the context from the Command if any Flag was set.
RemoteTxInvocationContext.
NonTxInvocationContext with the NonTxInvocationContext.isOriginLocal() returning true.
StoredMap persisted by the database
StoredMap persisted by the database
Cache as a parameter
LocalTxInvocationContext.
InternalCacheValue based on the InternalCacheEntry passed in.
ThreadLocalRandom.
System.nanoTime() is less expensive than System.currentTimeMillis() and better suited
to measure time intervals.
JdbcStringBasedCacheStore
and JdbcBinaryCacheStore.DataRehashed.DldGlobalTransaction with
appropriate information needed in order to accomplish deadlock detection.ClassLoader and a set of Flags.add(-1).
Version.getVersionShort().
Version.getVersionShort().
ExecutorFactory based on an ThreadPoolExecutor.GeneratedCacheKey implementation.CacheKeyGenerator implementation.Cache instance, and is often used as a
starting point to using the Cache.DefaultCacheManager.DefaultCacheManager(org.infinispan.configuration.cache.Configuration) instead
DefaultCacheManager.DefaultCacheManager(org.infinispan.configuration.cache.Configuration, boolean) instead
DefaultCacheManager.DefaultCacheManager(org.infinispan.configuration.global.GlobalConfiguration) instead
DefaultCacheManager.DefaultCacheManager(org.infinispan.configuration.global.GlobalConfiguration, boolean) instead
DefaultCacheManager.DefaultCacheManager(org.infinispan.configuration.global.GlobalConfiguration, org.infinispan.configuration.cache.Configuration, boolean) instead
CacheResolver implementation for
standalone environments, where no Cache/CacheManagers are injected via CDI.ConsistentHash implementation.ConsistentHashFactory.ContextClassLoader to add a default class loader
in case the context class loader is null.Configuration producer.EmbeddedCacheManager producer.ExecutorService and DistributedExecutorService.logAfterNumberOfDocuments
documents written.
RebalancePolicyRemoteCacheManager producer.TimeService.TwoWayKey2StringMapper that knows how to handle all primitive
wrapper keys and Strings.EmbeddedCacheManager.defineConfiguration(String, String, org.infinispan.config.Configuration) instead
EmbeddedCacheManager.defineConfiguration(String, org.infinispan.configuration.cache.Configuration) instead
InfinispanIndexInput instances are reading from it, then it will
be effectively deleted.
DeltaAware implementation.Deltas.SpringEmbeddedCacheManager instance created by this
FactoryBean.
stopRemoteCacheManager created by this factory.
EmbeddedCacheManager instance created by this
FactoryBean.
org.infinispan.Cache created by this FactoryBean.
org.infinispan.Cache created by this FactoryBean.
stopRemoteCacheManager created by this factory.
Directory implementation which stored data
in the data grid.FluentTypes.indexing()
method enables Indexing implicitly.
Group annotations are not used and any configured
groupers will not be be invoked
CompletionService that uses a supplied DistributedExecutorService to execute
tasks.LinkedBlockingQueue as a completion queue.
LongAdder.sum() as a double after a widening
primitive conversion.
Modification objects and
executes it against the CacheStore. Current commands supported are: STORE CLEAR
REMOVE PURGE_EXPIRED
RoundRobinBalancingStrategy.nextServer() without modifying indexes/state.
DummyTransactionManager.Configuration as being modifiable even after the cache has started.BdbjeCacheStoreCassandraCacheStoreCloudCacheStoreHBaseCacheStoreJdbmCacheStoreRemoteCacheStoreMapper implementor
Group annotations are honoured and any configured
groupers will be invoked
Group annotations are honored and any configured
groupers will be invoked
Group annotations are honored and any configured
groupers will be invoked
Group annotations are honored and any configured
groupers will be invoked
BackupConfiguration that have BackupConfiguration.enabled() == true.
Cache.startBatch().
MVCCEntry instances for use in the InvocationContext.EntryFactory implementation to be used for optimistic locking scheme.Set view of the mappings contained in this map.
Set view of the mappings contained in this map.
Set view of the mappings contained in this map.
Map.entrySet() functionality.EntryWrapper implementation to wrap cache entries
Configuration.equalsIgnoreName(Object) for equality that does not consider the name of the configuration.
Configuration.equals(Object) but it ignores the Configuration.getName() attribute in the comparison.
Comparable rules, but where the behaviour provided by the JDK, or
external libraries, cannot be modified, for example: arrays.initialCapacity) and
initial table density (loadFactor).
initialCapacity), table
density (loadFactor), and number of concurrently
updating threads (concurrencyLevel).
Set of (key, value)
entries.Set of keys, in
which additions may optionally be enabled by mapping to a
common value.Collection of
values, in which additions are disabled.Equivalence function implementations for keys
and values, as opposed to relying on their own equals/hashCode/toString
implementations.Equivalence function implementations for values,
as opposed to relying on their own equals/hashCode/toString implementations.Collator
Collator and wrapped by Future
DistributedTaskFailoverPolicy
DistributedTaskExecutionPolicy for the task being built
ExposedByteArrayOutputStream
but with the benefit of not having to allocate unnecessary byte arrays by not extending ByteArrayOutputStream.CacheEntryExpiredListener instances.Explanation
object describing the score computation for the matching object/document
in the current query
ModuleCommandFactory
interface.RiverMarshaller extension that allows Infinispan code to directly
create instances of it.RiverUnmarshaller that allows Infinispan StreamingMarshaller
instances to travel down the stack to potential externalizer implementations
that might need it, such as MarshalledValue.ExternalizerAdvancedExternalizer implementation that it marshall, and it also keeps information of which AdvancedExternalizer
should be used to read data from a buffer given a particular AdvancedExternalizer identifier.DistributedTask might potentially fail on subset of executing nodes FailureContext
provides details of such task failure.DistributedTaskFailoverPolicy for the task being built
BackupFailurePolicy.CUSTOM then the failurePolicyClass is required and
should return the fully qualified name of a class implementing CustomFailurePolicy
BackupFailurePolicy.CUSTOM then the failurePolicyClass is required and
should return the fully qualified name of a class implementing CustomFailurePolicy
IndexUpdateCommand.perform(InvocationContext)
true, the cache will fetch data from the neighboring caches when it starts up, so
the cache starts 'warm', although it will impact startup time.
true, the cache will fetch data from the neighboring caches when it starts up, so
the cache starts 'warm', although it will impact startup time.
false if by the current Transport
if the ResponseMode.isSynchronous() returns true.
BucketBasedCacheStore.FileCacheStore.FineGrainedAtomicMap to provide consistency and isolation for concurrent readers
while writes may also be going on.null.
LongAdder.sum() as a float
after a widening primitive conversion.
RecoveryManager.forceTransactionCompletion(javax.transaction.xa.Xid, boolean) on the specified node.
ForkJoinPool.commonPool() if not ForkJoinTask.inForkJoinPool().
ExecutorService for running ForkJoinTasks.ForkJoinPool with parallelism equal to Runtime.availableProcessors(), using the default thread factory,
no UncaughtExceptionHandler, and non-async LIFO processing mode.
ForkJoinPool with the indicated parallelism
level, the default thread factory,
no UncaughtExceptionHandler, and non-async LIFO processing mode.
ForkJoinPool with the given parameters.
ForkJoinWorkerThreads.ForkJoinPools.ForkJoinPool.ForkJoinPool, which executes
ForkJoinTasks.Node in a TreeCache.Node.
null if this map contains no mapping for the key.
null if this map contains no mapping for the
key.
null if this map contains no mapping for the key.
Map.get(Object) that allows user code to
retrieve the value associated with a key at a later stage, hence allowing
multiple parallel get requests to be sent.
true if this pool uses local first-in-first-out
scheduling mode for forked tasks that are never joined.
AtomicMapLookup.getAtomicMap(org.infinispan.Cache, Object)
RequestBalancingStrategy may not be thread-safe.
RemoteCache.getBulk(), but limits the returned set of values to the specified size.
CacheContainer.getCache(),
to return a Cache instead of a BasicCache
CacheContainer.getCache(String),
to return a Cache instead of a BasicCache
CacheContainer.getCache(String) does except that if offers the possibility for the
named cache not to be retrieved if it has not yet been started, or if
it's been removed after being started.
AdvancedCache.getCacheEntry(Object)
CacheKeyGenerator.
Configuration.getCacheLoaders(), Configuration.isCacheLoaderShared()
Configuration.isFetchPersistentState(), Configuration.isCacheLoaderPassivation()
and Configuration.isCacheLoaderPreload() instead
org.infinispan.client.hotrod.RemoteCache does
not support retrieving the set of all cache names from the hotrod server.
Callable for this task
null if none.
clone of the Configuration registered under the given name.
CacheLoaderConfig type.
CacheLoaderConfig type.
ConnectionFactory based on the supplied class
name.
ConsistentHash may not be thread-safe.
DefaultConsistentHash.
HashConfigurationBuilder.consistentHashFactory(org.infinispan.distribution.ch.ConsistentHashFactory) instead.
CustomInterceptorConfig, if any, associated with this configuration
object.
Node.
DataContainer
EmbeddedCacheManager.getDefaultCacheConfiguration() instead.
Please note that before this method was deprecated, modifications on the
Configuration returned would be applied to the default cache if it
was not started. Since the deprecation, this method returns a copy and
so any changes to the returned object won't have any impact on the
default cache instance.
RpcManager.getDefaultRpcOptions(boolean, boolean).
DistributionManager if the cache is configured
to use Distribution.
Configuration.getExpirationWakeUpInterval()
CancellationException if cancelled, or null if
none or if the method has not yet completed.
Fqn which represents the location of this Node in the cache structure.
EmbeddedCacheManager.getCacheManagerConfiguration() instead.
Please note that before this method was deprecated, modifications on the
GlobalConfiguration returned would be applied to the cache manager if it
was not started. Since the deprecation, this method returns a copy and
so any changes to the returned object won't have any impact on the cache
manager instance.
RecoveryManager.getInDoubtTransactionInfoFromCluster(), but only returns transactions from the local node.
Set containing all the in-doubt transactions from the cluster, including the local node.
Util.getInstance(Class) except that exceptions are propagated to the caller.
Util.getInstance(String, ClassLoader) except that exceptions are propagated to the caller.
Set containing the data in this Node.
Map.get(Object) and
Map.containsKey(Object) operationsFqn.SEPARATOR.
BucketBasedCacheStores the lock should be acquired at bucket level.
null if additions are not supported.
MBeanServer instance.
org.infinispan.manager.EmbeddedCacheManagerCacheManager.
org.infinispan.client.hotrod.RemoteCacheManagerSpringRemoteCacheManager.
DefaultFactoryFor annotation that is capable of creating the component
class).
TransactionXaAdapter corresponding to the supplied transaction.
TotalOrderRemoteTransactionState associated with this transaction, creating one if no one was
associated to this transaction.
StringPropertyReplacer.replaceProperties(java.lang.String) to the result.
StringPropertyReplacer.replaceProperties(java.lang.String) to the result.
CacheQuery, filtered according to a set of classes passed
in.
ForkJoinTask.join(), even
if this task completed abnormally, or null if this task
is not known to have been completed.
RemoteCacheManager that created this cache.
null if it is unconnected.
RemoteTransaction associated with the supplied transaction id.
getRpcOptionsBuilder(responseMode, true)
Stats object that allows several statistics associated
with this cache at runtime.
Status.STATUS_PREPARED if the tx is prepared
- Status.STATUS_COMMITTED if the tx is committed
- Status.STATUS_ROLLEDBACK if the tx is rollback
- null otherwise
Status field.
DistributedTaskExecutionPolicy for this task
DistributedTaskFailoverPolicy for this task
VersionedValue associated to the supplied key param, or null if it doesn't exist.
Configuration.getExpirationWakeUpInterval()
MetadataValue associated to the supplied key param, or null if it doesn't exist.
XAResource associated with this cache which can be
used to do transactional recovery.
GlobalConfiguration instead.DistributedCallable for obtaining all of the keys
across a cluster.Group annotation needs customizing.ConsistentHash wrapper that groups keys to the same node based on their @Group
annotation.RebalancePolicy.
RebalancePolicy
Fqn passed in exists.
Object.hashCode().
Equivalence
function associated with it.
Map, i.e.,
the sum of, for each key-value pair in the map,
key.hashCode() ^ value.hashCode().
true if there are any tasks submitted to this
pool that have not yet begun executing.
HBaseCacheStore.is quiescent.
VisitableCommand.shouldInvoke(InvocationContext) but evaluated by InvocationContextInterceptor.
LockSupportCacheStore.lockForWriting(Object), but with 0 timeout.
ImmortalCacheEntryMap.Entry} with an immutable Map.Entry}.
InternalCacheEntry} with an immutable InternalCacheEntry}.
Listenable.addListener(Object) API.add(1).
ParserRegistry insteadFactoryBeanorg.infinispan.Cacheconfigurableorg.infinispan.manager.CacheContainerDirectoryBuilder to create Directory instead.FactoryBeanInfinispan EmbeddedCacheManagerInfinispanDirectory.InfinispanDirectory.DirectoryFactoryBeannamed Infinispan org.infinispan.Cacheconfigurableorg.infinispan.manager.EmbeddedCacheManagerFactoryBeannamed Infinispan org.infinispan.Cacheconfigurableoorg.infinispan.client.hotrod.RemoteCacheManagerrNamespaceHandler for Infinispan-based caches.FactoryBeanInfinispan RemoteCacheManagertrue if the current thread is a ForkJoinWorkerThread executing as a ForkJoinPool computation.
JBossStandaloneJTAManagerLookup.init(org.infinispan.configuration.cache.Configuration) instead.
ReplicableCommand read from a data stream with components specific
to the target cache instance.
ModuleCommandFactory.fromStream(byte, Object[]) with
necessary named-cache-specific components.
DefaultExecutorService or MapReduceTaskInputInterceptorConfiguration instances to be referenced when building the interceptor
chain.
InternalCacheEntry and InternalCacheValue instances.LongAdder.sum() as an int after a narrowing
primitive conversion.
InvocationContext and the calling thread.RuntimeException or Error if the underlying
computation did so.
AccessibleObject.setAccessible(boolean)
isDone holds for
each task or an (unchecked) exception is encountered, in which
case the exception is rethrown.
isDone holds for
each task or an (unchecked) exception is encountered, in which
case the exception is rethrown.
isDone holds for each task or an (unchecked) exception
is encountered, in which case the exception is rethrown.
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, RpcOptions)
except that the task is passed to the transport executor and a Future is returned.
true if this task threw an exception or was cancelled.
true if this task completed without throwing an
exception and was not cancelled.
Configuration.getConsistentHashClass() is not used.
true if this set contains no elements.
Configuration.isDeadlockDetectionEnabled() instead.
InternalCacheEntry.isExpired(long)
InternalCacheValue.isExpired(long)
JdbcStringBasedCacheStore, but will be injected through JdbcStringBasedCacheStore.doConnectionFactoryInitialization(org.infinispan.loaders.jdbc.connectionfactory.ConnectionFactory)
ManagedOperation.name().true if all worker threads are currently idle.
true if blocking is unnecessary.
true if this pool has been shut down.
true.
true.
true.
true.
true.
true.
true if all tasks have completed following shut down.
true if the process of termination has
commenced but not yet completed.
Configuration.isTransactionAutoCommit()) to complete with 1 RPC
instead of 2 RPCs (which is default).
Future
as return type.
Configuration.isStoreAsBinary()
Synchronization.
ResultIterator.
ResultIterator.
ConcurrentModificationException, and
guarantees to traverse elements as they existed upon
construction of the iterator, and may (but is not
guaranteed to) reflect any modifications subsequent to
construction.
ConcurrentModificationException, and
guarantees to traverse elements as they existed upon
construction of the iterator, and may (but is not
guaranteed to) reflect any modifications subsequent to
construction.
ConcurrentModificationException, and
guarantees to traverse elements as they existed upon
construction of the iterator, and may (but is not
guaranteed to) reflect any modifications subsequent to
construction.
TransactionManager instance from "java:/TransactionManager".Cache interface.javax.cache.Cache.Entry.Iterables over Cache Entries, those of which
are filtered using a CacheEntryEventFilter.JCacheEventFilteringIterable.
Iterators to allow filtering of CacheEntryEventsJCacheEventFilteringIterator.
CacheEntryListenerRegistration.JCacheListenerRegistration.
CacheManager.ClassLoader.
UserTransaction facade for JCache's requirement to provide
access to a user transaction implementation.CachingProvider.BucketBasedCacheStore implementation that will store all the buckets as rows in database, each row
corresponding to a bucket.JdbcBinaryCacheStore.JdbcBinaryCacheStore and JdbcStringBasedCacheStore.JdbcMixedCacheStore.CacheStore implementation that stores the entries in a database.JdbcStringBasedCacheStore cache store.CacheLoader based on the JDBM project.JdbmCacheStore.StreamingMarshaller of the cache.ResponseFilter.MBeanParameterInfois
done.
Status.Key2StringMapper to use for mapping keys to strings suitable for
storage in a database table.
Key2StringMapper to use for mapping keys to strings suitable for
storage in a database table.
Key2StringMapper to use for mapping keys to strings suitable for
storage in a database table.
Key2StringMapper to use for mapping keys to strings suitable for
storage in a database table.
Key2StringMapper to use for mapping keys to strings suitable for
storage in a database table.
Key2StringMapper to use for mapping keys to strings suitable for
storage in a database table.
KeyAffinityService.Equivalence instance to use to compare keys stored in
data container.
KeyAffinityService to generate the affinity keys.MarshalledValueOrPrimitiveMapper by default)
MarshalledValueOrPrimitiveMapper by default)
Set view of the keys contained in this map.
Set view of the keys contained in this map.
Set view of the keys contained in this map.
Set view of the keys in this map, using the
given common mapped value for any additions (i.e., Collection.add(E) and Collection.addAll(java.util.Collection)).
Map.keySet() functionality.SSLContext You also need to
specify a SslConfigurationBuilder.keyStorePassword(char[]).
SSLContext You also need to
specify a #keyStorePassword(String).
SslConfigurationBuilder.keyStoreFileName(String) Alternatively specify an array of
#keyManagers(KeyManager[])
SslConfigurationBuilder.keyStoreFileName(String) Alternatively specify an array of
#keyManagers(KeyManager[])
IndexScopedKey which enforces visitability with a
KeyVisitor.ResultIterator.AdvancedExternalizer implementations to be registered.AdvancedExternalizer implementations to be registered.null the Infinispan classes'
classloader.
null the Infinispan classes' classloader.
DistributedSegmentReadLocker to minimize
remote operations in case several IndexReaders are opened on the same Infinispan based Directory.ClusterTopologyManager.LocalTopologyManager implementation.RemoteTransaction.LocalTransaction implementation to be used with TransactionXaAdapter.ConsistentHash.locateOwners(java.lang.Object) multiple times for each key in the collection of
keys and merging the results.
ConsistentHash.locateOwners(java.lang.Object).
LockManager.AbstractCacheStore adding lock support for consistently accessing stored data.LockSupportCacheStore.Log instances.Log instances.long sum.LongAdder.sum().
FileLookupFactory.DefaultFileLookup.
FileLookupFactory.DefaultFileLookup.
FileLookupFactory.DefaultFileLookup.
FileLookupFactory.DefaultFileLookup.
FileLookupFactory.DefaultFileLookup.
MBeanServer instance based on the
configuration parameters.
LuceneCacheLoader.ComponentMetadata, this version also includes JMX related metadata, as expressed
by MBean, ManagedAttribute and ManagedOperation annotations.Mapper and Reducer which is a
combiner to a remote Infinispan node where it will get executed and return the result to an
invoking/master node.MapReduceManager.MapReduceManager.MarshalledValues.TwoWayKey2StringMapper that supports both primitives
and MarshalledValues.Marshaller implementation to
serialize and deserialize user objects.
Marshaller implementation to
serialize and deserialize user objects.
Marshaller to serialize
and deserialize user objects.
Marshaller implementation to
serialize and deserialize user objects.
Marshaller implementation to
serialize and deserialize user objects.
ExhaustedAction.WAIT, after which a NoSuchElementException
will be thrown.
MBeanServerLookup class to be used to bound JMX MBeans to.
MBeanServerLookup class to be used to bound JMX MBeans to.
DeltaAware instance, and return a coherent and complete
DeltaAware instance.
Merged.ImmortalCacheEntry that
is MetadataAwareImmortalCacheValue that
is MetadataAwareMetadataAwareMetadataMortalCacheEntryMetadataAwareTransientCacheEntry which is
MetadataAwareTransientMortalCacheEntry
that is VersionedTransientMortalCacheValue that is VersionedCacheStore modificationModifications to be performed atomically via TransactionRunner.Modifications that will be applied to the supplied CacheStore
Inject,
Start or Stop annotations.ModuleProperties class represents Infinispan's module service extensionsMortalCacheEntryCache.MutableEntry designed to
be passed as parameter to Cache.EntryProcessor#process(javax.cache.Cache.MutableEntry).ComponentName annotation on the classes requested in Inject annotated methods.ResponseFilter.isAcceptable(Response, Address), this method is called to see whether we are done
with the request and can unblock the caller
KeyAffinityService instance that generates keys mapped to all addresses
in the cluster.
KeyAffinityServiceFactory.newKeyAffinityService(org.infinispan.Cache, java.util.concurrent.Executor, KeyGenerator, int,
boolean) with start == true;
KeyAffinityServiceFactory.newKeyAffinityService(org.infinispan.Cache, java.util.Collection, KeyGenerator,
java.util.concurrent.Executor, int, boolean) with start == true.
Set backed by a ConcurrentHashMapV8
from the given type to Boolean.TRUE.
Set backed by a ConcurrentHashMapV8
from the given type to Boolean.TRUE.
KeyAffinityServiceFactory.newLocalKeyAffinityService(org.infinispan.Cache, KeyGenerator, java.util.concurrent.Executor, int, boolean) with start == true.
ForkJoinTask.quietlyComplete() and returns null.
double value
between 0 (inclusive) and the specified value (exclusive).
named logical grouping of data in the TreeCache API of JBoss Cache.AtomicMapFuture and exposes it as an NotifyingFuture.NotifyingFuture.HashConfigurationBuilder.numSegments(int) instead.
HashConfiguration.numSegments() (which works like a
numVirtualNodes value for the entire cluster).
HashConfigurationBuilder.numSegments(int) (which works like a
numVirtualNodes value for the entire cluster).
StreamingMarshaller.objectFromInputStream(java.io.InputStream), but its
implementation has been moved here rather that keeping under a class that implements StreamingMarshaller
in order to avoid code duplication.
InputStream
ObjectInput
ByteBuffer which takes
an estimated size as parameter.
ByteBuffer, which allows direct access to the byte
array with minimal array copying
ObjectOutput
CountedCompleter.tryComplete() is invoked
and the pending count is zero, or when the unconditional
method CountedCompleter.complete(T) is invoked.
ForkJoinTask.completeExceptionally(java.lang.Throwable)
is invoked or method CountedCompleter.compute() throws an exception, and
this task has not otherwise already completed normally.
onKeys allows users to specify a
subset of keys as input to this task
HotRodOperation objects.AtomicMap interfaces and API that Infinispan exposes as building
blocks in creating other public interfaces such as the Tree API.Cache.startBatch() and Cache.endBatch(boolean)
API.CacheManager and its various Caches, and related
utilities.CacheStore implementation based on
Oracle's BDBJE storage engine.CacheStore implementation based on
persisting to Apache CassandraCacheStore implementation based on
JClouds, which in turn is an abstraction layer to store data on cloud infrastructure providers
such as Amazon's S3,
RackspaceCloud's CloudFiles,
Microsoft's Windows Azure Blob Storage API, and others.CacheLoader (not CacheStore) that polls other nodes in the cluster for state.CacheStore implementation.CacheStore implementation based on
persisting to HBase.CacheStore implementation based on
a JDBC database connection.CacheStore implementation based on
persisting to JDBM.CacheStore.Cache-specific notifications and eventing.CacheManager-specific notifications and eventing.TransactionManagers.DefaultBean from Solder. The OverrideDefault annotation is not necessary and will be removed in a future
release. See DefaultEmbeddedCacheManagerProducer and DefaultEmbeddedCacheConfigurationProducer
for more details.OwnableReentrantLocks.OwnableReentrantLock that has a reference counter, and implements RefCountingLock.org.infinispan.config.GlobalConfiguration#getDefaultConfiguration()
This is typically used to configure a DefaultCacheManager
ParserRegistryDataContainer.get(Object)}
except that it does not update or reorder any of the internal constructs.
MBeanServerLookup, will return the platform MBean server.InterceptorConfiguration.Position enumeration, where to place the new interceptor.
TransactionRunner, which allows us to prepare a transaction without committing it. The
transaction prepared is accessible via CurrentTransaction.getTransaction()superclass and caches a current reference to CurrentTransaction.
superclass and caches
a current reference to CurrentTransaction.
SleepyCat transaction associated with tx.
run, except that the
transaction is not committed on success.
TotalOrderRemoteTransactionState.prepared() is
invoked
TwoWayFieldBridge
Unless notified in their JavaDoc, all built-in bridges are two-way.
CountedCompleter.tryComplete() but does not invoke CountedCompleter.onCompletion(org.infinispan.util.concurrent.jdk8backported.CountedCompleter) along the completion path: If the pending count
is nonzero, decrements the count; otherwise, similarly tries to
complete this task's completer, if one exists, else marks this
task as complete.
StoredMap.entrySet() and remove, if expired.
#put(K, V), which takes in an instance of
Metadata which can be used to provide metadata information for
the entry being stored, such as lifespan, version of value...etc.
Flag.IGNORE_RETURN_VALUES
flag when invoking this method in order to make it behave as efficiently
as possible (i.e.
BasicCache.put(Object, Object), which takes in lifespan parameters.
BasicCache.put(Object, Object), which takes in lifespan parameters.
Node in this cache.
Node.
Map.putAll(Map), which takes in lifespan parameters.
Map.putAll(Map), which takes in lifespan parameters.
Map.putAll(Map).
BasicCache.putAll(Map, long, TimeUnit).
BasicCache.putAll(Map, long, TimeUnit, long, TimeUnit).
AdvancedCache.put(Object, Object, Metadata) which stores
metadata alongside the value.
BasicCache.put(Object, Object).
BasicCache.put(Object, Object, long, TimeUnit) .
BasicCache.put(Object, Object, long, TimeUnit, long, TimeUnit).
#putIfAbsent(K, V), which takes in an
instance of Metadata which can be used to provide metadata
information for the entry being stored, such as lifespan, version
of value...etc.
ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
ConcurrentMap.putIfAbsent(Object, Object), which takes in lifespan parameters.
ConcurrentMap.putIfAbsent(Object, Object).
BasicCache.putIfAbsent(Object, Object, long, TimeUnit) .
BasicCache.putIfAbsent(Object, Object, long, TimeUnit, long, TimeUnit).
BasicCache.put(Object, Object)getRoot().quietlyComplete().
RemoteCacheStore stores values wrapped in InternalCacheEntry.
Base64.InputStream.read() repeatedly until the end of stream
is reached or len bytes are read.
XmlConfigHelper.readStringContents(org.w3c.dom.Element,String) except that it returns a boolean.
XmlConfigHelper.readStringContents(org.w3c.dom.Element,String) except that it returns a boolean.
ImmutableListCopy.writeExternal(java.io.ObjectOutput) for serialization format
CacheLoader, i.e., suppressing all write
methods.AbstractQueuedSynchronizer.GlobalTransaction.LocalXaTransaction and adds recovery related information.RemoteTransaction and adds recovery related information and functionality.RecoveryManager.XAResource.recover(int).RecoveryManagerReducer to a remote Infinispan node where it will
get executed and return the result to an invoking/master node.Lock, with support for maintaining a reference counter.Annotated metadata.CancellationService under the given UUID id
Transformer for the supplied key class.
Synchronization callback with this transaction.
Transformer for the supplied key class.
StateTransferConfigurationBuilder.fetchInMemoryState(boolean) instead.
StateTransferConfiguration.fetchInMemoryState() instead.
StateTransferConfigurationBuilder.fetchInMemoryState(boolean) instead.
StateTransferConfigurationBuilder.fetchInMemoryState(boolean) instead.
StateTransferConfiguration.timeout() instead.
StateTransferConfigurationBuilder.timeout(long) instead.
StateTransferConfiguration.timeout() instead.
InternalCacheEntry.reincarnate(long)
fork.
RemoteCaches.Configuration.
Configuration.
RemoteCacheManager.RemoteCacheManager(java.util.Properties), but it will try to lookup the config properties in the
classpath, in a file named hotrod-client.properties.
RemoteCacheManager.RemoteCacheManager(boolean) and it also starts the cache.
RemoteCache that is associated to an
RemoteCacheManager that was not started.RemoteCache producer.ReplicableCommands from a byte stream.RemoteTransaction corresponding to the given tx.
Flag.IGNORE_RETURN_VALUES
flag when invoking this method in order to make it behave as efficiently
as possible (i.e.
CacheStore.remove(Object) modificationBasicCache.remove(Object).
ConcurrentMap.remove(Object, Object).
Fqn.
TransactionXaAdapter corresponding to the given tx.
Node indicated by absolute Fqn.
RecoveryManager.removeRecoveryInformation(javax.transaction.xa.Xid) but identifies the tx by its internal id.
#removeRecoveryInformationFromCluster(java.util.Collection but the transaction
is identified by its internal id, and not by its xid.
ReadCommittedEntry that provides Repeatable Read semantics#replace(K, V), which takes in an
instance of Metadata which can be used to provide metadata
information for the entry being stored, such as lifespan, version
of value...etc.
#replace(K, V, V), which takes in an
instance of Metadata which can be used to provide metadata
information for the entry being stored, such as lifespan, version
of value...etc.
ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
ConcurrentMap.replace(Object, Object), which takes in lifespan parameters.
ConcurrentMap.replace(Object, Object, Object), which takes in lifespan parameters.
Node.putAll(java.util.Map) except that it removes any entries that exists in the data map first.
ConcurrentMap.replace(Object, Object).
BasicCache.replace(Object, Object, long, TimeUnit).
BasicCache.replace(Object, Object, long, TimeUnit, long, TimeUnit).
ConcurrentMap.replace(Object, Object, Object).
BasicCache.replace(Object, Object, Object, long, TimeUnit).
BasicCache.replace(Object, Object, Object, long, TimeUnit, long, TimeUnit).
RemoteCache.replaceWithVersion(Object, Object, long)
which takes in lifespan parameters.
RemoteCache.replaceWithVersion(Object, Object, long)
which takes in lifespan and maximum idle time parameters.
ConsistentHash for replicated caches.ReplicationQueueImpl.
ReplicationQueueImpl.
XMLStreamException if one is found.
XMLStreamException if it contains any child
elements.
ResponseFilter.
ResponseMode for the remote invocation.
ReversibleOrderedSet.reverseIterator() method.CacheEntryEvent.CacheStatisticsMXBean.Random's distribution to generate keys.CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean).
CacheStore.prepare(java.util.List, org.infinispan.transaction.xa.GlobalTransaction, boolean).
TransactionXaAdapter.prepare(javax.transaction.xa.Xid) applies for commit.
RequestBalancingStrategy.Transport.Transport implementation,
and is used to set up the transport and provide lifecycle and dependency hooks into external transport
implementations.RpcOptions instances with the options to be used in remote invocations.RpcOptions
org.hibernate.search.cfg.SearchConfiguration so that within Infinispan-Query, there is
no need for a Hibernate Core configuration object.Xid is not Serializable and
we need to serialize it and send it over the network.Externalizer class.ClassExternalizerFactory that
allows for Infinispan annotations to be used instead of JBoss Marshalling
ones in order to discover which classes are serializable with Infinispan
externalizers.GlobalConfiguration.GlobalJmxStatisticsType.allowDuplicateDomains(Boolean) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.allowDuplicateDomains(Boolean) instead
FluentConfiguration.StateRetrievalConfig.alwaysProvideInMemoryState(Boolean) instead
Configuration.StateRetrievalType.alwaysProvideInMemoryState(Boolean) instead
FluentGlobalTypes.asyncListenerExecutor() instead
FluentGlobalTypes.asyncListenerExecutor() instead
FluentGlobalTypes.asyncListenerExecutor() instead
Configuration.AsyncType.asyncMarshalling(Boolean)
CacheStoreConfig.asyncStore() instead
FluentGlobalTypes.asyncTransportExecutor() instead
FluentGlobalTypes.asyncTransportExecutor() instead
FluentGlobalTypes.asyncTransportExecutor() instead
FluentConfiguration.LoadersConfig.addCacheLoader(org.infinispan.loaders.CacheLoaderConfig...) instead
GlobalConfiguration.GlobalJmxStatisticsType.cacheManagerName(String) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.cacheManagerName(String) instead
FluentConfiguration.ClusteringConfig.mode(org.infinispan.config.Configuration.CacheMode) instead
FluentConfiguration.ClusteringConfig.mode(org.infinispan.config.Configuration.CacheMode) instead
FluentConfiguration.ClusteringConfig.mode(org.infinispan.config.Configuration.CacheMode) instead
name of the org.infinispan.Cachename of the org.infinispan.CacheFluentConfiguration.TransactionConfig.cacheStopTimeout(Integer) instead
Configuration.TransactionType.cacheStopTimeout(Integer) instead
FluentGlobalConfiguration.TransportConfig.clusterName(String) instead
GlobalConfiguration.TransportType.clusterName(String) instead
Configuration.LockingType.concurrencyLevel(Integer) instead
FluentConfiguration.LockingConfig.concurrencyLevel(Integer) instead
locationEmbeddedCacheManagerSpringEmbeddedCacheManagerFactoryBean delegates
to.
HashConfigurationBuilder.consistentHashFactory(org.infinispan.distribution.ch.ConsistentHashFactory) instead.
HashConfigurationBuilder.consistentHashFactory(org.infinispan.distribution.ch.ConsistentHashFactory) instead.
Configuration.CustomInterceptorsType.add(org.infinispan.interceptors.base.CommandInterceptor) instead
FluentConfiguration.CustomInterceptorCumulator.add(org.infinispan.interceptors.base.CommandInterceptor)
FluentConfiguration.DeadlockDetectionConfig.spinDuration(Long) instead
FluentGlobalConfiguration.TransportConfig.distributedSyncTimeout(Long) instead
GlobalConfiguration.TransportType.distributedSyncTimeout(Long) instead
FluentConfiguration.TransactionConfig.eagerLockSingleNode(Boolean) instead
Configuration.TransactionType.eagerLockSingleNode(Boolean) instead
Configuration.BooleanAttributeType.enabled(Boolean) instead
AbstractConfigurationBeanWithGCR.globalJmxStatistics() instead
AbstractFluentConfigurationBean.deadlockDetection() instead
FluentConfiguration.EvictionConfig.maxEntries(Integer) instead
FluentGlobalTypes.evictionScheduledExecutor() instead
FluentGlobalTypes.evictionScheduledExecutor() instead
FluentGlobalTypes.evictionScheduledExecutor() instead
FluentConfiguration.EvictionConfig.strategy(org.infinispan.eviction.EvictionStrategy) instead
FluentConfiguration.EvictionConfig.strategy(org.infinispan.eviction.EvictionStrategy) instead
FluentConfiguration.EvictionConfig.threadPolicy(org.infinispan.eviction.EvictionThreadPolicy) instead
FluentConfiguration.EvictionConfig.threadPolicy(org.infinispan.eviction.EvictionThreadPolicy) instead
FluentConfiguration.ExpirationConfig.wakeUpInterval(Long) instead
FluentConfiguration.ExpirationConfig.lifespan(Long) instead
FluentConfiguration.ExpirationConfig.maxIdle(Long) instead
AbstractConfigurationBeanWithGCR.globalJmxStatistics() instead
AbstractFluentConfigurationBean.jmxStatistics() instead
AdvancedExternalizer
implementation that knows how to marshall or unmarshall instances of one, or
several, user-defined, types.
FluentConfiguration.StateRetrievalConfig.fetchInMemoryState(Boolean) instead
Configuration.StateRetrievalType.fetchInMemoryState(Boolean) instead
CacheStoreConfig.fetchPersistentState(Boolean) instead
AsyncStoreConfig.flushLockTimeout(Long) instead.
Configuration.HashType.hashFunctionClass(Class)
FluentConfiguration.HashConfig.hashFunctionClass(Class) instead
GlobalConfiguration.ShutdownType.hookBehavior(org.infinispan.config.GlobalConfiguration.ShutdownHookBehavior) instead
AdvancedExternalizer
implementations, providing a more performant way to ship class information around
rather than passing class names or class information in general around.
CacheStoreConfig.ignoreModifications(Boolean) instead
AbstractFluentConfigurationBean.indexing() instead
Configuration.QueryConfigurationBean.indexLocalOnly(Boolean) instead
FluentConfiguration.IndexingConfig.indexLocalOnly(Boolean) instead
org.infinispan.manager.CacheContainerCacheorg.infinispan.manager.EmbeddedCacheManagerCacheorg.infinispan.client.hotrod.RemoteCacheManagerCacheConfiguration.StateRetrievalType.initialRetryWaitTime(Long) instead
AbstractFluentConfigurationBean.invocationBatching() instead
Configuration.LockingType.isolationLevel(org.infinispan.util.concurrent.IsolationLevel) instead
FluentConfiguration.LockingConfig.isolationLevel(org.infinispan.util.concurrent.IsolationLevel) instead
FluentConfiguration.LockingConfig.isolationLevel(org.infinispan.util.concurrent.IsolationLevel) instead
GlobalConfiguration.GlobalJmxStatisticsType.jmxDomain(String) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.jmxDomain(String) instead
AbstractFluentConfigurationBean.l1() instead
#invalidationReaperThreadFrequency(Long)
FluentConfiguration.L1Config.invalidationThreshold(Integer) instead
FluentConfiguration.L1Config.lifespan(Long) instead
FluentConfiguration.L1Config.onRehash(Boolean) instead
Configuration.ExpirationType.lifespan(Long)
Configuration.L1Type.lifespan(Long)
FileCacheStoreConfig.location(String)
Configuration.LockingType.lockAcquisitionTimeout(Long) instead
FluentConfiguration.LockingConfig.lockAcquisitionTimeout(Long) instead
FluentConfiguration.LockingConfig.lockAcquisitionTimeout(Long) instead
Configuration.StateRetrievalType.logFlushTimeout(Long) instead
FluentGlobalConfiguration.TransportConfig.machineId(String) instead
GlobalConfiguration.TransportType.machineId(String) instead
GlobalConfiguration.SerializationType.marshallerClass(Class) instead
FluentGlobalConfiguration.SerializationConfig.marshallerClass(Class) instead
FluentGlobalConfiguration.SerializationConfig.version(short) instead
FluentGlobalConfiguration.SerializationConfig.version(String) instead
Configuration.EvictionType.maxEntries(Integer)
Configuration.ExpirationType.maxIdle(Long)
Configuration.StateRetrievalType.maxNonProgressingLogWrites(Integer) instead
GlobalConfiguration.GlobalJmxStatisticsType.mBeanServerLookupClass(Class) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.mBeanServerLookupClass(Class) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.mBeanServerLookup(org.infinispan.jmx.MBeanServerLookup) instead
GlobalConfiguration.GlobalJmxStatisticsType.mBeanServerLookup(org.infinispan.jmx.MBeanServerLookup) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.mBeanServerLookup(org.infinispan.jmx.MBeanServerLookup) instead
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.withProperties(java.util.Properties) or
FluentGlobalConfiguration.GlobalJmxStatisticsConfig.addProperty(String, String) instead
#mode(CacheMode)
GlobalConfiguration.TransportType.nodeName(String) instead
Configuration.HashType.numOwners(Integer)
FluentConfiguration.HashConfig.numOwners(Integer) instead
Configuration.StateRetrievalType.numRetries(Integer) instead
HashConfigurationBuilder.numSegments(int) instead.
Configuration.L1Type.onRehash(Boolean)
CommandsFactory to create a command from raw data read off a stream.
CacheLoaderManagerConfig.passivation(Boolean) instead.
CacheLoaderManagerConfig.preload(Boolean) instead.
GlobalConfiguration.FactoryClassWithPropertiesType.addProperty(String, String) or GlobalConfiguration.FactoryClassWithPropertiesType.withProperties(java.util.Properties) instead
GlobalConfiguration.GlobalJmxStatisticsType.withProperties(java.util.Properties) instead
GlobalConfiguration.TransportType.withProperties(java.util.Properties) or GlobalConfiguration.TransportType.addProperty(String, String) instead
CacheStoreConfig.purgeOnStartup(Boolean) instead
AbstractCacheStoreConfig.purgerThreads(Integer) instead
CacheStoreConfig.purgeSynchronously(Boolean) instead
SingletonStoreConfig.pushStateTimeout(Long) instead.
SingletonStoreConfig.pushStateWhenCoordinator(Boolean) instead.
FluentGlobalConfiguration.TransportConfig.rackId(String) instead
GlobalConfiguration.TransportType.rackId(String) instead
Configuration.HashType.rehashEnabled(Boolean)
FluentConfiguration.HashConfig.rehashEnabled(Boolean) instead
Configuration.HashType.rehashRpcTimeout(Long)
FluentConfiguration.HashConfig.rehashRpcTimeout(Long) instead
Configuration.HashType.rehashWait(Long)
FluentConfiguration.HashConfig.rehashWait(Long) instead
ClusterCacheLoaderConfig.remoteCallTimeout(long)
FluentGlobalTypes.replicationQueueScheduledExecutor() instead
FluentGlobalTypes.replicationQueueScheduledExecutor() instead
FluentGlobalTypes.replicationQueueScheduledExecutor() instead
Configuration.AsyncType.replQueueClass(Class)
FluentConfiguration.AsyncConfig.replQueueClass(Class) instead
Configuration.AsyncType.replQueueInterval(Long)
FluentConfiguration.AsyncConfig.replQueueInterval(Long) instead
FluentConfiguration.AsyncConfig.replQueueInterval(Long) instead
Configuration.AsyncType.replQueueMaxElements(Integer)
FluentConfiguration.AsyncConfig.replQueueMaxElements(Integer) instead
Configuration.SyncType.replTimeout(Long)
Configuration.StateRetrievalType.retryWaitTimeIncreaseFactor(Integer) instead
UnsupportedOperationException.
CacheLoaderManagerConfig.shared(Boolean) instead.
FluentGlobalConfiguration.ShutdownConfig.hookBehavior(org.infinispan.config.GlobalConfiguration.ShutdownHookBehavior) instead
FluentGlobalConfiguration.ShutdownConfig.hookBehavior(org.infinispan.config.GlobalConfiguration.ShutdownHookBehavior) instead
AsyncStoreConfig.shutdownTimeout(Long) instead.
CacheStoreConfig.singletonStore() instead
CacheStoreConfig.singletonStore() instead.
FluentGlobalConfiguration.TransportConfig.siteId(String) instead
GlobalConfiguration.TransportType.siteId(String) instead
Configuration.DeadlockDetectionType.spinDuration(Long)
FluentConfiguration.StateRetrievalConfig.chunkSize(Integer) instead
FluentConfiguration.StateRetrievalConfig.initialRetryWaitTime(Long) instead
FluentConfiguration.StateRetrievalConfig.initialRetryWaitTime(Long) instead
FluentConfiguration.StateRetrievalConfig.logFlushTimeout(Long) instead
FluentConfiguration.StateRetrievalConfig.logFlushTimeout(Long) instead
FluentConfiguration.StateRetrievalConfig.maxNonProgressingLogWrites(Integer) instead
FluentConfiguration.StateRetrievalConfig.numRetries(Integer) instead
FluentConfiguration.StateRetrievalConfig.retryWaitTimeIncreaseFactor(Integer) instead
FluentConfiguration.StateRetrievalConfig.timeout(Long) instead
FluentConfiguration.StateRetrievalConfig.timeout(Long) instead
Configuration.EvictionType.strategy(EvictionStrategy)
FileCacheStoreConfig.streamBufferSize(int) instead
FluentGlobalConfiguration.TransportConfig.strictPeerToPeer(Boolean) instead
GlobalConfiguration.TransportType.strictPeerToPeer(Boolean) instead
FluentConfiguration.TransactionConfig.syncCommitPhase(Boolean) instead
Configuration.TransactionType.syncCommitPhase(Boolean) instead
FluentConfiguration.SyncConfig.replTimeout(Long) instead
FluentConfiguration.SyncConfig.replTimeout(Long) instead
FluentConfiguration.TransactionConfig.syncRollbackPhase(Boolean) instead
Configuration.TransactionType.setSyncRollbackPhase(Boolean) instead
Configuration.EvictionType.threadPolicy(EvictionThreadPolicy)
AsyncStoreConfig.threadPoolSize(Integer) instead.
Configuration.StateRetrievalType.timeout(Long) instead
FluentConfiguration.TransactionConfig.transactionManagerLookup(TransactionManagerLookup) instead
FluentConfiguration.TransactionConfig.transactionManagerLookupClass(Class) instead
Configuration.TransactionType.transactionManagerLookupClass(Class) instead
TotalOrderLatch to be associated to this transaction
DummyBaseTransactionManager.begin() method.
DummyUserTransaction.begin() method.
FluentGlobalConfiguration.TransportConfig.transportClass(Class) instead
GlobalConfiguration.TransportType.transportClass(Class) instead
FluentGlobalConfiguration.TransportConfig.nodeName(String) instead
FluentGlobalConfiguration.TransportConfig.withProperties(java.util.Properties) or
FluentGlobalConfiguration.TransportConfig.addProperty(String, String) instead
FluentGlobalConfiguration.TransportConfig.withProperties(java.util.Properties) or
FluentGlobalConfiguration.TransportConfig.addProperty(String, String) instead
Configuration.UnsafeType.unreliableReturnValues(Boolean) instead
FluentConfiguration.UnsafeConfig.unreliableReturnValues(Boolean) instead
FluentConfiguration.AsyncConfig.asyncMarshalling(Boolean) instead
FluentConfiguration.TransactionConfig.useEagerLocking(Boolean) instead
Configuration.TransactionType.useEagerLocking(Boolean) instead
Future
as return type.
AbstractFluentConfigurationBean.storeAsBinary() instead
Configuration.LockingType.useLockStriping(Boolean) instead
FluentConfiguration.LockingConfig.useLockStriping(Boolean) instead
Configuration.AsyncType.useReplQueue(Boolean)
FluentConfiguration.AsyncConfig.useReplQueue(Boolean) instead
GlobalConfiguration.SerializationType.version(String) instead
Configuration.VersioningConfigurationBean.versioningScheme(org.infinispan.configuration.cache.VersioningScheme)
FluentConfiguration.ExpirationConfig.wakeUpInterval(Long)
Configuration.LockingType.writeSkewCheck(Boolean) instead
FluentConfiguration.LockingConfig.writeSkewCheck(Boolean) instead
MultipleRpcCommand, but it only aggregates a single command for
replication.ReplicationQueue.
Cacheorg.infinispan.CacheCacheManagerInfinispan EmbeddedCacheManagerFactoryBeanSpringEmbeddedCacheManagerCacheManagerInfinispan RemoteCacheManagerFactoryBeanSpringRemoteCacheManagerSSLContext to use for setting up SSL connections.
Environment, then opens the databases.
org.infinispan.client.hotrod.RemoteCacheManagerSpringRemoteCacheManager.
StateConsumer implementation.StateProvider implementation.stateTransfer sub element for distributed and replicated caches.
StateTransferManager,
StateConsumer
and StateProvider instances.StateTransferLock implementation.StateTransferManager implementation.ComponentStatus.TERMINATED once it
is done.
EmbeddedCacheManagerCacheManager delegates to.
org.infinispan.client.hotrod.RemoteCacheManagerSpringRemoteCacheManager.
CacheStore.store(org.infinispan.container.entries.InternalCacheEntry)Marshaller that supports streams.Element.
CacheLoader implemtations thread safe.StripedLock.StripedLock(int) with a default concurrency value of 20.
LongAdder.sum() followed by LongAdder.reset().
true and cannot be modified since version 5.3
ComponentRegistry,
that are meant to be retained in the component registry even after the component registry is stopped.TransactionConfigurationBuilder.syncCommitPhase(boolean)
ConsistentHashFactory implementation that guarantees caches with the same members
have the same consistent hash.Synchronization implementation for integrating with the TM.LocalTransaction implementation to be used with SynchronizationAdapter.timeDuration(startTime, time(), outputTimeUnit).
DistributedTask task timeout
MapReduceTask.timeout(TimeUnit).
TimeUnit.
RpcOptionsBuilder.timeout(long, java.util.concurrent.TimeUnit)
InternalCacheValue.
ConsistentHashFactory implementation that guarantees caches
with the same members have the same consistent hash and also tries to distribute segments based on the
topology information in TransportConfiguration.ConsistentHash implementation
in use by the DistributionManager changes due to a change in cluster topology.TopologyChanged.key value.
Fqn.SEPARATOR and joining each subsequent
element with a Fqn.SEPARATOR.
LongAdder.sum().
org.infinispan.commands.tx.PrepareCommand delivered in total order to coordinate
conflicting transactions and between org.infinispan.commands.tx.PrepareCommand and state transfer (blocking
the prepare until the state transfer is finished and blocking the state transfer until all the prepared transactions
has finished)TotalOrderLatchProperties instance to an instance of TypedProperties, if needed.
Properties instance to an instance of TypedProperties
Properties instance to an instance of TypedProperties, if needed.
InternalCacheEntry.touch(long)
TransactionContext interface.InfinispanDirectory,
this factory produces instances of TransactionalSharedLuceneLock.GlobalTransactionTransactionCompleted.TransactionManager.Cache to use different transactional systems.TransactionManager.
Synchronization with a registered TransactionManager.TransactionRegistered.RemoteTransaction and TransactionXaAdapters (locally
originated transactions).TransactionTable objects.CacheTransaction and implementor of an XAResource that will be called by tx manager on various tx stages.InfinispanCollections.MapMakerFunction
TransientCacheEntryTransientMortalCacheEntryTransport objects.Cache allowing for efficient tree-style access to cached data.TreeCacheRebalancePolicy to start a state transfer.
SSLContext You also need
to specify a SslConfigurationBuilder.trustStorePassword(char[]).
SSLContext You also need
to specify a #trustStorePassword(String).
SslConfigurationBuilder.trustStoreFileName(String) Alternatively specify an array of
#trustManagers(TrustManager[])
SslConfigurationBuilder.trustStoreFileName(String) Alternatively specify an array of
#trustManagers(TrustManager[])
CountedCompleter.onCompletion(org.infinispan.util.concurrent.jdk8backported.CountedCompleter) and then similarly
tries to complete this task's completer, if one exists,
else marks this task as complete.
Key2StringMapper and allows a bidirectional transformation between keys and Strings.InvocationContextContainer.createInvocationContext(boolean, int) as an indicator
of the fact that the size of the keys to be accessed in the context is not known.
ObjectInput that delegates all methods except ObjectInput.close().ObjectOutput.CancellationService given an id
ObjectName
ComponentsJmxRegistration.registerMBeans().
Map contract when providing return values for
BasicCache.put(Object, Object) and BasicCache.remove(Object) methods.
Map contract when providing return values for
BasicCache.put(Object, Object) and BasicCache.remove(Object) methods.
InternalCacheEntry with new metadata.
ClusterCacheStatus.removeMember(Address),
ClusterCacheStatus.updateClusterMembers(java.util.List) etc.)
Configuration.isUse1PcForAutoCommitTransactions().
TransactionConfigurationBuilder.useSynchronization(boolean)
Equivalence instance to use to compare values stored in
data container.
Collection view of the values contained in this map.
Collection view of the values contained in this map.
Collection view of the values contained in this map.
Map.values() functionality.JBossMarshaller.CommitCommand except that version information is also carried by this command, used by
optimistically transactional caches making use of write skew checking when using IsolationLevel.REPEATABLE_READ.TxDistributionInterceptor that adds logic to handling prepares when entries are versioned.PrepareCommand except that the transaction originator makes evident the versions of entries touched
and stored in a transaction context so that accurate write skew checks may be performed by the lock owner(s).ViewChanged.ReentrantLock only to make the VisibleOwnerReentrantLock.getOwner() method public.VisibleOwnerReentrantLock that has a reference counter, and implements RefCountingLock.Visitors, such as CommandInterceptors.true if the transaction is complete or false otherwise.
WeakValueHashMap with the given
initial capacity and the given load factor.
WeakValueHashMap with the given
initial capacity and the default load factor, which is
0.75.
WeakValueHashMap with the default
initial capacity and the default load factor, which is
0.75.
WeakValueHashMap with the same mappings as
the specified Map.
Inject annotation, creating more components
as needed based on the Configuration passed in if these additional components don't exist in the ComponentRegistry.
AdvancedCache operation
with a given ClassLoader.
Flags to the scope of a single invocation.
DataContainer configuration
Base64.OutputStream.write(int) repeatedly until len
bytes are written.
TransactionTable to be used with TransactionXaAdapter.
|
--> | |||||||||