|
Infinispan Distribution 5.2.6.Final-redhat-2 | |||||||||
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
CacheNotifierImpl
LoaderConfigurationChildBuilder
methods to a specified CacheLoaderConfigurationBuilder
LockSupportStoreConfigurationChildBuilder
methods
to a specified LockSupportStoreConfigurationBuilder
ModuleLifecycle
interface, designed for easy
extension.AbstractConfigurationBean
.StoreConfigurationChildBuilder
methods to a specified CacheStoreConfigurationBuilder
GlobalTransaction
TxInvocationContext
.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
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
.null
.
Set
with the given elements.
AtomicMap
.AtomicHashMap
to provide consistency and isolation for concurrent readers
while writes may also be going on.terminate()
.
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).
BackupReceiver
s 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.Executors
except that the factory methods here allow you to specify the
size of the blocking queue that backs the executor.RpcManager.broadcastRpcCommand(org.infinispan.commands.ReplicableCommand, boolean)
except that the task
is passed to the transport executor and a Future is returned.
RpcManager.broadcastRpcCommand(org.infinispan.commands.ReplicableCommand, boolean, boolean)
except that
the task is passed to the transport executor and a Future is returned.
CacheStoreConfig
level.
#buildCreateCacheCommand(String, String, false)
.
GetInDoubtTransactionsCommand
.
CommandsFactory.buildLockControlCommand(Object, java.util.Set, org.infinispan.transaction.xa.GlobalTransaction)
but for locking a single key vs a collection of keys.
TxCompletionNotificationCommand
.
PutKeyValueCommand
that also holds a reference to a version to be applied.
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.Cache
.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
CancellationService
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()
.
ClusterCacheLoader
.ClusteredGetCommand
s.ClusterTopologyManager
implementation.Mapper
ReplicableCommand
s.Visitor
interface allowing it to
intercept invocations on VisitableCommand
s.DeltaAware.delta()
) and can be
discarded.
TransactionXaAdapter.prepare(javax.transaction.xa.Xid)
applies for commit.
join
and related operations.
join
and related operations.
Scope
, SurvivesRestarts
,
DefaultFactoryFor
, ComponentName
, Inject
, Start
and Stop
annotations.Inject
Start
or @Stop
null
if there is no current
mapping).
RecoveryAwareRemoteTransaction.isOrphan()
.
initialCapacity
) and
initial table density (loadFactor
).
initialCapacity
), table
density (loadFactor
), and number of concurrently
updating threads (concurrencyLevel
).
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
s.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.MurmurHash2
;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.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
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.
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 Flag
s.add(-1)
.
Version.getVersionShort()
.
Version.getVersionShort()
.
ExecutorFactory
based on an ThreadPoolExecutor
.CacheKey
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.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.
RebalancePolicy
RemoteCacheManager
producer.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.Delta
s.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.
RoundRobinBalancingStrategy.nextServer()
without modifying indexes/state.
DummyTransactionManager
.Configuration
as being modifiable even after the cache has started.RemoteCacheStore
RemoteCacheStore
Mapper
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.
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
.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.Externalizer
AdvancedExternalizer
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.
BucketBasedCacheStore
.FileCacheStore
.FineGrainedAtomicMap
to provide consistency and isolation for concurrent readers
while writes may also be going on.Flag
.LongAdder.sum()
as a float
after a widening primitive conversion.
RecoveryManager.forceTransactionCompletion(javax.transaction.xa.Xid, boolean)
on the specified node.
ExecutorService
for running ForkJoinTask
s.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.
ForkJoinWorkerThread
s.ForkJoinPool
s.ForkJoinPool
.ForkJoinPool
, which executes
ForkJoinTask
s.CacheRpcCommand
based on the command
id and argument array passed in.
ReplicableCommand
based on the command
id and argument array passed in.
CacheRpcCommand
from the stream.
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.
CacheEntry
instead of just the value.CacheKeyGenerator
.
Configuration.getCacheLoaders()
, Configuration.isCacheLoaderShared()
Configuration.isFetchPersistentState()
, Configuration.isCacheLoaderPassivation()
and Configuration.isCacheLoaderPreload()
instead
Callable
for this task
clone
of the Configuration
registered under the given name.
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.
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.
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.
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.
Map.get(Object)
and
Map.containsKey(Object)
operationsBucketBasedCacheStore
s the lock should be acquired at bucket level.
MBeanServer
instance.
DefaultFactoryFor
annotation that is capable of creating the component
class).
TransactionXaAdapter
corresponding to the supplied transaction.
OutboundSocketBinding
in all SocketBindingGroup
s
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.
SocketBinding
in all SocketBindingGroup
s
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.Group
annotation needs customizing.ConsistentHash
wrapper that groups keys to the same node based on their @Group
annotation.RebalancePolicy
.
RebalancePolicy
Object.hashCode()
.
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.
is quiescent
.
VisitableCommand.shouldInvoke(InvocationContext)
but evaluated by InvocationContextInterceptor
.
LockSupportCacheStore.lockForWriting(Object)
, but with 0 timeout.
ImmortalCacheEntry
Map.Entry
} with an immutable Map.Entry
}.
InternalCacheEntry
} with an immutable InternalCacheEntry
}.
Listenable.addListener(Object)
API.add(1)
.
AnnotationProvider
implementation.ParserRegistry
insteadDirectory
which uses Infinispan to store Lucene indexes.InfinispanDirectory
Directory
true
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 MapReduceTask
Input
InterceptorConfiguration
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, boolean)
except that the task is passed to the transport executor and a Future is returned.
RpcManager.invokeRemotely(java.util.Collection, org.infinispan.commands.ReplicableCommand, boolean)
except that the task is passed to the transport executor and a Future is returned.
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand,
boolean, org.infinispan.util.concurrent.NotifyingNotifiableFuture)
except that you can specify a timeout.
RpcManager.invokeRemotelyInFuture(java.util.Collection, org.infinispan.commands.ReplicableCommand,
boolean, org.infinispan.util.concurrent.NotifyingNotifiableFuture, long)
except that you can specify a response mode.
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.
Configuration.isDeadlockDetectionEnabled()
instead.
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
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
.
TransactionManager
instance from "java:/TransactionManager".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.ResponseFilter
.MBeanParameterInfo
is
done
.
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
.KeyAffinityService
to generate the affinity keys.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.
Map.keySet()
functionality.IndexScopedKey
which enforces visitability with a
KeyVisitor
.ResultIterator
.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 InfinispanDirectory
.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
.
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
.MarshalledValue
s.TwoWayKey2StringMapper
that supports both primitives
and MarshalledValue
s.Marshaller
implementation to
serialize and deserialize user objects.
Marshaller
implementation to
serialize and deserialize user objects.
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
.CacheStore
modificationInject
,
Start
or Stop
annotations.ModuleProperties
class represents Infinispan's module service extensionsMortalCacheEntry
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.
KeyAffinityServiceFactory.newLocalKeyAffinityService(org.infinispan.Cache, KeyGenerator, java.util.concurrent.Executor, int, boolean)
with start == true.
double
value
between 0 (inclusive) and the specified value (exclusive).
Future
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
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 Cache
s, and related
utilities.CacheLoader
(not CacheStore
) that polls other nodes in the cluster for state.CacheStore
implementation.CacheStore
implementation based on
a JDBC database connection.CacheStore
.Cache
-specific notifications and eventing.CacheManager
-specific notifications and eventing.TransactionManager
s.DefaultBean
from Solder. The OverrideDefault annotation is not necessary and will be removed in a future
release. See DefaultEmbeddedCacheManagerProducer
and DefaultEmbeddedCacheConfigurationProducer
for more details.OwnableReentrantLock
s.OwnableReentrantLock
that has a reference counter, and implements RefCountingLock
.ConcurrentHashMapV8.Parallel
view of this map using the
given executor for bulk parallel operations.
org.infinispan.config.GlobalConfiguration#getDefaultConfiguration()
This is typically used to configure a DefaultCacheManager
ParserRegistry
DataContainer.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.
TwoWayFieldBridge
Unless notified in their JavaDoc, all built-in bridges are two-way.
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.
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)
.
BasicCache.put(Object, Object)
.
BasicCache.put(Object, Object, long, TimeUnit)
.
BasicCache.put(Object, Object, long, TimeUnit, long, TimeUnit)
.
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)
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)
.RecoveryManager
Reducer
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.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.
fork
.
RemoteCache
s.Marshaller
for marshalling
keys and values to be send over to the remote Infinispan cluster.
Marshaller
for marshalling
keys and values to be send over to the remote Infinispan cluster.
RemoteCacheManager.RemoteCacheManager(Marshaller, java.util.Properties, boolean)
with start = true.
RemoteCacheManager.RemoteCacheManager(Marshaller, java.util.Properties, boolean)
with start = true.
RemoteCacheManager.RemoteCacheManager(Marshaller, java.util.Properties, boolean)
with start = true.
RemoteCacheManager.RemoteCacheManager(java.util.Properties, boolean)
, and it also starts the cache (start==true).
RemoteCacheManager.RemoteCacheManager(java.util.Properties, boolean)
, and it also starts the cache (start==true).
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.
RemoteCacheManager.RemoteCacheManager(String, int, boolean)
with start=true.
RemoteCacheManager.RemoteCacheManager(String, int, boolean)
with start=true.
RemoteCacheManager.RemoteCacheManager(String, boolean)
, with start=true.
RemoteCacheManager.RemoteCacheManager(String, boolean)
, with start=true.
RemoteCacheManager.RemoteCacheManager(java.util.Properties)
, but it will try to lookup the config properties in
supplied URL.
RemoteCacheManager.RemoteCacheManager(java.util.Properties)
, but it will try to lookup the config properties in
supplied URL.
RemoteCacheManager.RemoteCacheManager(java.net.URL)
and it also starts the cache (start==true).
RemoteCacheManager.RemoteCacheManager(java.net.URL)
and it also starts the cache (start==true).
RemoteCache
that is associated to an
RemoteCacheManager
that was not started.RemoteCache
producer.ReplicableCommand
s 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)
.
TransactionXaAdapter
corresponding to the given tx.
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 semanticsConcurrentMap.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.
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.
Cache
to use for this CacheInvocationContext
.
ReversibleOrderedSet.reverseIterator()
method.Random
's distribution to generate keys.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.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
FluentConfiguration.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
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
Configuration.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
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.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.
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()
.
ComponentRegistry
,
that are meant to be retained in the component registry even after the component registry is stopped.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
.DistributedTask
task timeout
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
.LongAdder.sum()
.
Properties
instance to an instance of TypedProperties, if needed.
Properties
instance to an instance of TypedProperties
Properties
instance to an instance of TypedProperties, if needed.
TransactionContext
interface.InfinispanDirectory
,
this factory produces instances of TransactionalSharedLuceneLock
.GlobalTransaction
TransactionCompleted
.TransactionManager
.Cache
to use different transactional systems.TransactionManager
.
Synchronization
with a registered TransactionManager
.TransactionRegistered
.RemoteTransaction
and TransactionXaAdapter
s (locally
originated transactions).TransactionTable
objects.CacheTransaction
and implementor of an XAResource
that will be called by tx manager on various tx stages.InfinispanCollections.MapMakerFunction
TransientCacheEntry
TransientMortalCacheEntry
Transport
objects.RebalancePolicy
to start a state transfer.
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 lifespan and maxIdle values.
ClusterCacheStatus.removeMember(Address)
,
ClusterCacheStatus.updateClusterMembers(java.util.List)
etc.)
Configuration.isUse1PcForAutoCommitTransactions()
.
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.ImmortalCacheEntry
that is Versioned
ImmortalCacheValue
that is Versioned
MortalCacheEntry
that is Versioned
MortalCacheValue
that is 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).PutKeyValueCommand
that also applies a version to the entry created.ReplicationInterceptor
that adds additional logic to how prepares are handled.TransientCacheEntry
that is Versioned
TransientCacheValue
that is Versioned
TransientMortalCacheEntry
that is Versioned
TransientMortalCacheValue
that is Versioned
ViewChanged
.ReentrantLock
only to make the VisibleOwnerReentrantLock.getOwner()
method public.VisibleOwnerReentrantLock
that has a reference counter, and implements RefCountingLock
.Visitor
s, such as CommandInterceptor
s.true
if the transaction is complete or false
otherwise.
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
.
Flag
s 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
.
|
Infinispan Distribution 5.2.6.Final-redhat-2 | |||||||||
PREV NEXT | FRAMES NO FRAMES |