|
Infinispan Distribution 5.1.5.FINAL-redhat-1 | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
CacheLoader that holds common implementations for some methodsCacheStore that holds common implementations for some methodsAbstractCacheStore.AbstractDelegatingCache, but for AdvancedCache.AdvancedExternalizer implementations that offers default
implementations for some of its methods.CacheManagerNotifierImpl and
CacheNotifierImplModuleLifecycle interface, designed for easy
extension.AbstractConfigurationBean
.GlobalTransactionTxInvocationContext.LockManager.acquireLock(org.infinispan.context.InvocationContext, Object), but doesn't check whether the
lock is already acquired by the caller.
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.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.NotifyingNotifiableFuture implementation that allows a dynamic number of futures to be attached.AtomicMap.AtomicHashMap to provide consistency and isolation for concurrent readers
while writes may also be going on.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.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.
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).
Configuration.isExposeJmxStatistics() is true, then class will register all the MBeans from cache local's
ConfigurationRegistry to the MBean server.CacheLoader implementation if there are problems reading from a loader.CacheViewsManager instances.RpcManager only replicates commands wrapped in a CacheRpcCommand.CacheStarted.CacheStopped.CacheLoader interface that can be written to.chunkSize cache entries.
chunkSize cache entries.
CacheStore.clear() modificationMap.clear().
ClusterCacheLoader.ClusteredGetCommands.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.
Scope, SurvivesRestarts,
DefaultFactoryFor, ComponentName, Inject, Start and Stop annotations.InjectStart or @Stopnull 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).
null if there is no current
mapping).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.Configurations.ConnectionFactory.ConsistentHash function.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.
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.
RemoteTransaction with no modifications.
RemoteTxInvocationContext.
NonTxInvocationContext with the NonTxInvocationContext.isOriginLocal() returning true.
LocalTxInvocationContext.
InternalCacheValue based on the InternalCacheEntry passed in.
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.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
ContextClassLoader to add a default class loader
in case the context class loader is null.ExecutorService and DistributedExecutorService.TwoWayKey2StringMapper that knows how to handle all primitive
wrapper keys and Strings.#defineConfiguration(String, String, org.infinispan.configuration.cache.Configuration) instead
EmbeddedCacheManager.defineConfiguration(String, org.infinispan.configuration.cache.Configuration) instead
DeltaAware implementation.Deltas.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.
StateTransferManagerLongAdder.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.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
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.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
ExposedByteArrayOutputStream
but with the benefit of not having to allocate unnecessary byte arrays byt not extending ByteArrayOutputStream.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.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.
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.
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.
Configuration.getCacheLoaders(), Configuration.isCacheLoaderShared()
Configuration.isFetchPersistentState(), Configuration.isCacheLoaderPassivation()
and Configuration.isCacheLoaderPreload() instead
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.
CustomInterceptorConfig, if any, associated with this configuration
object.
DataContainer
DistributionManager if the cache is configured
to use Distribution.
Configuration.getExpirationWakeUpInterval()
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) operationsBucketBasedCacheStores 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.
normalizedHash.
StringPropertyReplacer.replaceProperties(java.lang.String) to the result.
StringPropertyReplacer.replaceProperties(java.lang.String) to the result.
RemoteCacheManager that created this cache.
null if it is unconnected.
RemoteTransaction associated with the supplied transaction id.
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.
VersionedValue associated to the supplied key param, or null if it doesn't exist.
Configuration.getExpirationWakeUpInterval()
XAResource associated with this cache which can be
used to do transactional recovery.
GlobalConfiguration instead.Group annotation needs customizing.Object.hashCode().
Map, i.e.,
the sum of, for each key-value pair in the map,
key.hashCode() ^ value.hashCode().
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).
Parser insteadReplicableCommand read from a data stream with components specific
to the target cache instance.
ModuleCommandFactory.fromStream(byte, Object[]) with
necessary named-cache-specific components.
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.InvocationContext without changing the context directly
but making sure the specified flags are considered enabled.InvocationContext without changing the context directly
but making sure the specified flags are considered enabled.
AccessibleObject.setAccessible(boolean)
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.
Configuration.isDeadlockDetectionEnabled() instead.
JdbcStringBasedCacheStore, but will be injected through JdbcStringBasedCacheStore.doConnectionFactoryInitialization(org.infinispan.loaders.jdbc.connectionfactory.ConnectionFactory)
Configuration.isTransactionAutoCommit()) to complete with 1 RPC
instead of 2 RPCs (which is default).
Future
as return type.
Configuration.isStoreAsBinary()
Synchronization.
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.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.null the Infinispan classes'
classloader.
null the Infinispan classes' classloader.
RemoteTransaction.LocalTransaction implementation to be used with TransactionXaAdapter.ConsistentHash.locate(Object, int) multiple times for each key in the collection of
keys.
DistributionManager.locateAll(java.util.Collection), but the list of addresses only contains numOwners owners.
LockManager.AbstractCacheStore adding lock support for consistently accessing stored data.LockSupportCacheStore.Log instances.Log instances.long sum.LongAdder.sum().
FileLookupFactory.DefaultFileLookup.
DefaultFileLookup.
FileLookupFactory.DefaultFileLookup.
DefaultFileLookup.
MBeanServer instance based on the
configuration parameters.
ComponentMetadata, this version also includes JMX related metadata, as expressed
by MBean, ManagedAttribute and ManagedOperation annotations.Mapper and Reducer to remote JVM where they
will get invoked.MarshalledValues.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 extensionsMortalCacheEntryComponentName 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.
NotifyingFuture.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 Caches, 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.TransactionManagers.OwnableReentrantLocks.org.infinispan.config.GlobalConfiguration#getDefaultConfiguration()
This is typically used to configure a DefaultCacheManager
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.
ConsistentHash.locate(Object, int).
Map.put(Object, Object), which takes in lifespan parameters.
Map.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).
Map.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).
Map.put(Object, Object)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).RecoveryManagerSynchronization callback with this transaction.
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.
RemoteCaches.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.ReplicableCommands from a byte stream.RemoteTransaction corresponding to the given tx.
CacheStore.remove(Object) modificationMap.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.
StateTransferManagerReplicationQueueImpl.
ReplicationQueueImpl.
XMLStreamException if one is found.
XMLStreamException if it contains any child
elements.
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.Xid is not Serializable and
we need to serialize it and send it over the network.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
Configuration.HashType.consistentHashClass(Class)
FluentConfiguration.HashConfig.consistentHashClass(Class) 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
Configuration.HashType.numVirtualNodes(Integer)
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
CacheEntry instead of the corresponding value associated with the key.
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.Namespace.UNKNOWN value.
stateTransfer sub element for distributed and replicated caches.
if (stateTransferLock.acquireForCommand()) {
try {
// execute this command!
} finally {
stateTransferLock.releaseForCommand(cmd);
}
}
StateTransferLock is locked.StateTransferLock.waitForStateTransferToEnd fails to re-acquire
the state transfer lock after state transfer (most likely because the timeout expired).StateTransferManager instances.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.Synchronization implementation for integrating with the TM.LocalTransaction implementation to be used with SynchronizationAdapter.InternalCacheValue.
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.
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.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.ObjectName
ComponentsJmxRegistration.registerMBeans().
Map contract when providing return values for
Map.put(Object, Object) and Map.remove(Object) methods.
Map contract when providing return values for
Map.put(Object, Object) and Map.remove(Object) methods.
InternalCacheEntry with new lifespan and maxIdle values.
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.DistributionInterceptor that adds logic to handling prepares when entries are versioned.ImmortalCacheEntry that is VersionedImmortalCacheValue that is VersionedMortalCacheEntry that is VersionedMortalCacheValue that is VersionedPrepareCommand 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 VersionedTransientCacheValue that is VersionedTransientMortalCacheEntry that is VersionedTransientMortalCacheValue that is VersionedViewChanged.Visitors, such as CommandInterceptors.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.
|
Infinispan Distribution 5.1.5.FINAL-redhat-1 | |||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||