Interface CommandsFactory

  • All Known Implementing Classes:
    CommandsFactoryImpl

    public interface CommandsFactory
    A factory to build commands, initializing and injecting dependencies accordingly. Commands built for a specific, named cache instance cannot be reused on a different cache instance since most commands contain the cache name it was built for along with references to other named-cache scoped components.

    Commands returned by the various build*Command methods should be initialised sufficiently for local execution via the interceptor chain, with no calls to initializeReplicableCommand(ReplicableCommand, boolean) required. However, for remote execution, it's assumed that a command will be initialized via initializeReplicableCommand(ReplicableCommand, boolean) before being invoked.

    Note, InitializableCommand implementations should not rely on access to the ComponentRegistry in their constructors for local execution initialization as this leads to duplicated code. Instead implementations of this interface should call InitializableCommand.init(ComponentRegistry, boolean) before returning the created command.

    Since:
    4.0
    Author:
    Manik Surtani, Mircea.Markus@jboss.com, Galder ZamarreƱo
    • Method Detail

      • buildPutKeyValueCommand

        default org.infinispan.commands.write.PutKeyValueCommand buildPutKeyValueCommand​(Object key,
                                                                                         Object value,
                                                                                         int segment,
                                                                                         Metadata metadata,
                                                                                         long flagsBitSet)
        Builds a PutKeyValueCommand
        Parameters:
        key - key to put
        value - value to put
        segment - the segment of the given key
        metadata - metadata of entry
        flagsBitSet - Command flags provided by cache
        Returns:
        a PutKeyValueCommand
      • buildPutKeyValueCommand

        org.infinispan.commands.write.PutKeyValueCommand buildPutKeyValueCommand​(Object key,
                                                                                 Object value,
                                                                                 int segment,
                                                                                 Metadata metadata,
                                                                                 long flagsBitSet,
                                                                                 boolean returnEntry)
      • buildRemoveCommand

        default org.infinispan.commands.write.RemoveCommand buildRemoveCommand​(Object key,
                                                                               Object value,
                                                                               int segment,
                                                                               long flagsBitSet)
        Builds a RemoveCommand
        Parameters:
        key - key to remove
        value - value to check for ina conditional remove, or null for an unconditional remove.
        segment - the segment of the given key
        flagsBitSet - Command flags provided by cache
        Returns:
        a RemoveCommand
      • buildRemoveCommand

        org.infinispan.commands.write.RemoveCommand buildRemoveCommand​(Object key,
                                                                       Object value,
                                                                       int segment,
                                                                       long flagsBitSet,
                                                                       boolean returnEntry)
      • buildInvalidateCommand

        org.infinispan.commands.write.InvalidateCommand buildInvalidateCommand​(long flagsBitSet,
                                                                               Object... keys)
        Builds an InvalidateCommand
        Parameters:
        flagsBitSet - Command flags provided by cache
        keys - keys to invalidate
        Returns:
        an InvalidateCommand
      • buildInvalidateFromL1Command

        org.infinispan.commands.write.InvalidateCommand buildInvalidateFromL1Command​(long flagsBitSet,
                                                                                     Collection<Object> keys)
        Builds an InvalidateFromL1Command
        Parameters:
        flagsBitSet - Command flags provided by cache
        keys - keys to invalidate
        Returns:
        an InvalidateFromL1Command
      • buildRemoveExpiredCommand

        org.infinispan.commands.write.RemoveExpiredCommand buildRemoveExpiredCommand​(Object key,
                                                                                     Object value,
                                                                                     int segment,
                                                                                     Long lifespan,
                                                                                     long flagsBitSet)
        Builds an expired remove command that is used to remove only a specific entry when it expires via lifespan
        Parameters:
        key - the key of the expired entry
        value - the value of the entry when it was expired
        segment - the segment of the given key
        lifespan - the lifespan that expired from the command
        flagsBitSet - Command flags provided by cache
        Returns:
        a RemovedExpiredCommand
      • buildRemoveExpiredCommand

        org.infinispan.commands.write.RemoveExpiredCommand buildRemoveExpiredCommand​(Object key,
                                                                                     Object value,
                                                                                     int segment,
                                                                                     long flagsBitSet)
        Builds an expired remove command that is used to remove only a specific entry when it expires via maxIdle
        Parameters:
        key - the key of the expired entry
        value - the value of the entry when it was expired
        segment - the segment of the given key
        flagsBitSet - Command flags provided by cache
        Returns:
        a RemovedExpiredCommand
      • buildReplaceCommand

        default org.infinispan.commands.write.ReplaceCommand buildReplaceCommand​(Object key,
                                                                                 Object oldValue,
                                                                                 Object newValue,
                                                                                 int segment,
                                                                                 Metadata metadata,
                                                                                 long flagsBitSet)
        Builds a ReplaceCommand
        Parameters:
        key - key to replace
        oldValue - existing value to check for if conditional, null if unconditional.
        newValue - value to replace with
        segment - the segment of the given key
        metadata - metadata of entry
        flagsBitSet - Command flags provided by cache
        Returns:
        a ReplaceCommand
      • buildReplaceCommand

        org.infinispan.commands.write.ReplaceCommand buildReplaceCommand​(Object key,
                                                                         Object oldValue,
                                                                         Object newValue,
                                                                         int segment,
                                                                         Metadata metadata,
                                                                         long flagsBitSet,
                                                                         boolean returnEntry)
        Builds a ReplaceCommand
        Parameters:
        key - key to replace
        oldValue - existing value to check for if conditional, null if unconditional.
        newValue - value to replace with
        segment - the segment of the given key
        metadata - metadata of entry
        flagsBitSet - Command flags provided by cache
        returnEntry - true if the CacheEntry is the command response, otherwise returns previous value.
        Returns:
        a ReplaceCommand
      • buildComputeCommand

        org.infinispan.commands.write.ComputeCommand buildComputeCommand​(Object key,
                                                                         BiFunction mappingFunction,
                                                                         boolean computeIfPresent,
                                                                         int segment,
                                                                         Metadata metadata,
                                                                         long flagsBitSet)
        Builds a ComputeCommand
        Parameters:
        key - key to compute if this key is absent
        mappingFunction - BiFunction for the key and the value
        computeIfPresent - flag to apply as computeIfPresent mode
        segment - the segment of the given key
        metadata - metadata of entry
        flagsBitSet - Command flags provided by cache
        Returns:
        a ComputeCommand
      • buildComputeIfAbsentCommand

        org.infinispan.commands.write.ComputeIfAbsentCommand buildComputeIfAbsentCommand​(Object key,
                                                                                         Function mappingFunction,
                                                                                         int segment,
                                                                                         Metadata metadata,
                                                                                         long flagsBitSet)
        Builds a ComputeIfAbsentCommand
        Parameters:
        key - key to compute if this key is absent
        mappingFunction - mappingFunction for the key
        segment - the segment of the given key
        metadata - metadata of entry
        flagsBitSet - Command flags provided by cache
        Returns:
        a ComputeCommand
      • buildSizeCommand

        org.infinispan.commands.read.SizeCommand buildSizeCommand​(IntSet segments,
                                                                  long flagsBitSet)
        Builds a SizeCommand
        Parameters:
        flagsBitSet - Command flags provided by cache
        Returns:
        a SizeCommand
      • buildGetKeyValueCommand

        org.infinispan.commands.read.GetKeyValueCommand buildGetKeyValueCommand​(Object key,
                                                                                int segment,
                                                                                long flagsBitSet)
        Builds a GetKeyValueCommand
        Parameters:
        key - key to get
        segment - the segment of the given key
        flagsBitSet - Command flags provided by cache
        Returns:
        a GetKeyValueCommand
      • buildGetCacheEntryCommand

        org.infinispan.commands.read.GetCacheEntryCommand buildGetCacheEntryCommand​(Object key,
                                                                                    int segment,
                                                                                    long flagsBitSet)
        Builds a GetCacheEntryCommand
        Parameters:
        key - key to get
        segment - the segment for the key
        flagsBitSet - Command flags provided by cache
        Returns:
        a GetCacheEntryCommand
      • buildGetAllCommand

        org.infinispan.commands.read.GetAllCommand buildGetAllCommand​(Collection<?> keys,
                                                                      long flagsBitSet,
                                                                      boolean returnEntries)
        Builds a GetAllCommand
        Parameters:
        keys - keys to get
        flagsBitSet - Command flags provided by cache
        returnEntries - boolean indicating whether entire cache entries are returned, otherwise return just the value parts
        Returns:
        a GetKeyValueCommand
      • buildKeySetCommand

        org.infinispan.commands.read.KeySetCommand buildKeySetCommand​(long flagsBitSet)
        Builds a KeySetCommand
        Parameters:
        flagsBitSet - Command flags provided by cache
        Returns:
        a KeySetCommand
      • buildEntrySetCommand

        org.infinispan.commands.read.EntrySetCommand buildEntrySetCommand​(long flagsBitSet)
        Builds a EntrySetCommand
        Parameters:
        flagsBitSet - Command flags provided by cache
        Returns:
        a EntrySetCommand
      • buildPutMapCommand

        org.infinispan.commands.write.PutMapCommand buildPutMapCommand​(Map<?,​?> map,
                                                                       Metadata metadata,
                                                                       long flagsBitSet)
        Builds a PutMapCommand
        Parameters:
        map - map containing key/value entries to put
        metadata - metadata of entry
        flagsBitSet - Command flags provided by cache
        Returns:
        a PutMapCommand
      • buildClearCommand

        org.infinispan.commands.write.ClearCommand buildClearCommand​(long flagsBitSet)
        Builds a ClearCommand
        Parameters:
        flagsBitSet - Command flags provided by cache
        Returns:
        a ClearCommand
      • buildEvictCommand

        org.infinispan.commands.write.EvictCommand buildEvictCommand​(Object key,
                                                                     int segment,
                                                                     long flagsBitSet)
        Builds an EvictCommand
        Parameters:
        key - key to evict
        segment - the segment for the key
        flagsBitSet - Command flags provided by cache
        Returns:
        an EvictCommand
      • buildPrepareCommand

        org.infinispan.commands.tx.PrepareCommand buildPrepareCommand​(GlobalTransaction gtx,
                                                                      List<org.infinispan.commands.write.WriteCommand> modifications,
                                                                      boolean onePhaseCommit)
        Builds a PrepareCommand
        Parameters:
        gtx - global transaction associated with the prepare
        modifications - list of modifications
        onePhaseCommit - is this a one-phase or two-phase transaction?
        Returns:
        a PrepareCommand
      • buildVersionedPrepareCommand

        org.infinispan.commands.tx.VersionedPrepareCommand buildVersionedPrepareCommand​(GlobalTransaction gtx,
                                                                                        List<org.infinispan.commands.write.WriteCommand> modifications,
                                                                                        boolean onePhase)
        Builds a VersionedPrepareCommand
        Parameters:
        gtx - global transaction associated with the prepare
        modifications - list of modifications
        onePhase -
        Returns:
        a VersionedPrepareCommand
      • buildCommitCommand

        org.infinispan.commands.tx.CommitCommand buildCommitCommand​(GlobalTransaction gtx)
        Builds a CommitCommand
        Parameters:
        gtx - global transaction associated with the commit
        Returns:
        a CommitCommand
      • buildVersionedCommitCommand

        org.infinispan.commands.tx.VersionedCommitCommand buildVersionedCommitCommand​(GlobalTransaction gtx)
        Builds a VersionedCommitCommand
        Parameters:
        gtx - global transaction associated with the commit
        Returns:
        a VersionedCommitCommand
      • buildRollbackCommand

        org.infinispan.commands.tx.RollbackCommand buildRollbackCommand​(GlobalTransaction gtx)
        Builds a RollbackCommand
        Parameters:
        gtx - global transaction associated with the rollback
        Returns:
        a RollbackCommand
      • initializeReplicableCommand

        @Deprecated
        void initializeReplicableCommand​(ReplicableCommand command,
                                         boolean isRemote)
        Deprecated.
        since 11.0, please use CacheRpcCommand.invokeAsync(ComponentRegistry) or GlobalRpcCommand.invokeAsync(GlobalComponentRegistry) instead. to access any components required at invocation time.
        Initializes a ReplicableCommand read from a data stream with components specific to the target cache instance.

        Implementations should also be deep, in that if the command contains other commands, these should be recursed into.

        Parameters:
        command - command to initialize. Cannot be null.
        isRemote -
      • buildSingleRpcCommand

        @Deprecated
        default org.infinispan.commands.remote.SingleRpcCommand buildSingleRpcCommand​(ReplicableCommand call)
        Deprecated.
        Builds a SingleRpcCommand "envelope" containing a single ReplicableCommand
        Parameters:
        call - ReplicableCommand to include in the envelope
        Returns:
        a SingleRpcCommand
      • buildSingleRpcCommand

        org.infinispan.commands.remote.SingleRpcCommand buildSingleRpcCommand​(VisitableCommand command)
        Builds a SingleRpcCommand "envelope" containing a single ReplicableCommand
        Parameters:
        command - VisitableCommand to include in the envelope
        Returns:
        a SingleRpcCommand
      • buildClusteredGetCommand

        org.infinispan.commands.remote.ClusteredGetCommand buildClusteredGetCommand​(Object key,
                                                                                    Integer segment,
                                                                                    long flagsBitSet)
        Builds a ClusteredGetCommand, which is a remote lookup command
        Parameters:
        key - key to look up
        segment - the segment for the key or null if it should be computed on the remote node
        flagsBitSet - Command flags provided by cache
        Returns:
        a ClusteredGetCommand
      • buildClusteredGetAllCommand

        org.infinispan.commands.remote.ClusteredGetAllCommand buildClusteredGetAllCommand​(List<?> keys,
                                                                                          long flagsBitSet,
                                                                                          GlobalTransaction gtx)
        Builds a ClusteredGetAllCommand, which is a remote lookup command
        Parameters:
        keys - key to look up
        flagsBitSet - Command flags provided by cache
        Returns:
        a ClusteredGetAllCommand
      • buildLockControlCommand

        org.infinispan.commands.control.LockControlCommand buildLockControlCommand​(Collection<?> keys,
                                                                                   long flagsBitSet,
                                                                                   GlobalTransaction gtx)
        Builds a LockControlCommand to control explicit remote locking
        Parameters:
        keys - keys to lock
        flagsBitSet - Command flags provided by cache
        gtx -
        Returns:
        a LockControlCommand
      • buildLockControlCommand

        org.infinispan.commands.control.LockControlCommand buildLockControlCommand​(Collection<?> keys,
                                                                                   long flagsBitSet)
      • buildConflictResolutionStartCommand

        org.infinispan.commands.statetransfer.ConflictResolutionStartCommand buildConflictResolutionStartCommand​(int topologyId,
                                                                                                                 IntSet segments)
      • buildStateTransferCancelCommand

        org.infinispan.commands.statetransfer.StateTransferCancelCommand buildStateTransferCancelCommand​(int topologyId,
                                                                                                         IntSet segments)
      • buildStateTransferGetListenersCommand

        org.infinispan.commands.statetransfer.StateTransferGetListenersCommand buildStateTransferGetListenersCommand​(int topologyId)
      • buildStateTransferGetTransactionsCommand

        org.infinispan.commands.statetransfer.StateTransferGetTransactionsCommand buildStateTransferGetTransactionsCommand​(int topologyId,
                                                                                                                           IntSet segments)
      • buildStateTransferStartCommand

        org.infinispan.commands.statetransfer.StateTransferStartCommand buildStateTransferStartCommand​(int topologyId,
                                                                                                       IntSet segments)
      • buildScatteredStateGetKeysCommand

        org.infinispan.commands.statetransfer.ScatteredStateGetKeysCommand buildScatteredStateGetKeysCommand​(int topologyId,
                                                                                                             IntSet segments)
      • buildScatteredStateConfirmRevokeCommand

        org.infinispan.commands.statetransfer.ScatteredStateConfirmRevokedCommand buildScatteredStateConfirmRevokeCommand​(int topologyId,
                                                                                                                          IntSet segments)
      • buildStateResponseCommand

        org.infinispan.commands.statetransfer.StateResponseCommand buildStateResponseCommand​(int viewId,
                                                                                             Collection<org.infinispan.statetransfer.StateChunk> stateChunks,
                                                                                             boolean applyState,
                                                                                             boolean pushTransfer)
        Builds a StateResponseCommand used for pushing cache entries to another node.
      • getCacheName

        String getCacheName()
        Retrieves the cache name this CommandFactory is set up to construct commands for.
        Returns:
        the name of the cache this CommandFactory is set up to construct commands for.
      • buildGetInDoubtTransactionsCommand

        org.infinispan.commands.remote.recovery.GetInDoubtTransactionsCommand buildGetInDoubtTransactionsCommand()
        Builds a GetInDoubtTransactionsCommand.
      • buildTxCompletionNotificationCommand

        org.infinispan.commands.remote.recovery.TxCompletionNotificationCommand buildTxCompletionNotificationCommand​(XidImpl xid,
                                                                                                                     GlobalTransaction globalTransaction)
        Builds a TxCompletionNotificationCommand.
      • buildGetInDoubtTxInfoCommand

        org.infinispan.commands.remote.recovery.GetInDoubtTxInfoCommand buildGetInDoubtTxInfoCommand()
        See Also:
        GetInDoubtTxInfoCommand
      • buildCompleteTransactionCommand

        org.infinispan.commands.remote.recovery.CompleteTransactionCommand buildCompleteTransactionCommand​(XidImpl xid,
                                                                                                           boolean commit)
        Builds a CompleteTransactionCommand command.
        Parameters:
        xid - the xid identifying the transaction we want to complete.
        commit - commit(true) or rollback(false)?
      • buildTxCompletionNotificationCommand

        org.infinispan.commands.remote.recovery.TxCompletionNotificationCommand buildTxCompletionNotificationCommand​(long internalId)
        Parameters:
        internalId - the internal id identifying the transaction to be removed.
        See Also:
        TxCompletionNotificationCommand
      • buildXSiteStatePushCommand

        XSiteStatePushCommand buildXSiteStatePushCommand​(XSiteState[] chunk,
                                                         long timeoutMillis)
        Builds XSiteStatePushCommand used to transfer a single chunk of data between sites.
        Parameters:
        chunk - the data chunk
        timeoutMillis - timeout in milliseconds, for the retries in the receiver site.
        Returns:
        the XSiteStatePushCommand created
      • buildSingleXSiteRpcCommand

        org.infinispan.xsite.SingleXSiteRpcCommand buildSingleXSiteRpcCommand​(VisitableCommand command)
        Builds SingleRpcCommand used to perform VisitableCommand on the backup site,
        Parameters:
        command - the visitable command.
        Returns:
        the SingleXSiteRpcCommand created
      • buildTxReadOnlyKeyCommand

        <K,​V,​R> org.infinispan.commands.functional.TxReadOnlyKeyCommand<K,​V,​R> buildTxReadOnlyKeyCommand​(Object key,
                                                                                                                                 Function<EntryView.ReadEntryView<K,​V>,​R> f,
                                                                                                                                 List<org.infinispan.commands.functional.Mutation<K,​V,​?>> mutations,
                                                                                                                                 int segment,
                                                                                                                                 Params params,
                                                                                                                                 DataConversion keyDataConversion,
                                                                                                                                 DataConversion valueDataConversion)
      • buildTxReadOnlyManyCommand

        <K,​V,​R> org.infinispan.commands.functional.TxReadOnlyManyCommand<K,​V,​R> buildTxReadOnlyManyCommand​(Collection<?> keys,
                                                                                                                                   List<List<org.infinispan.commands.functional.Mutation<K,​V,​?>>> mutations,
                                                                                                                                   Params params,
                                                                                                                                   DataConversion keyDataConversion,
                                                                                                                                   DataConversion valueDataConversion)
      • buildBackupAckCommand

        org.infinispan.commands.write.BackupAckCommand buildBackupAckCommand​(long id,
                                                                             int topologyId)
      • buildBackupMultiKeyAckCommand

        org.infinispan.commands.write.BackupMultiKeyAckCommand buildBackupMultiKeyAckCommand​(long id,
                                                                                             int segment,
                                                                                             int topologyId)
      • buildExceptionAckCommand

        org.infinispan.commands.write.ExceptionAckCommand buildExceptionAckCommand​(long id,
                                                                                   Throwable throwable,
                                                                                   int topologyId)
      • buildInvalidateVersionsCommand

        org.infinispan.commands.write.InvalidateVersionsCommand buildInvalidateVersionsCommand​(int topologyId,
                                                                                               Object[] keys,
                                                                                               int[] topologyIds,
                                                                                               long[] versions,
                                                                                               boolean removed)
      • buildRevokeBiasCommand

        org.infinispan.commands.remote.RevokeBiasCommand buildRevokeBiasCommand​(Address ackTarget,
                                                                                long id,
                                                                                int topologyId,
                                                                                Collection<Object> keys)
      • buildRenewBiasCommand

        org.infinispan.commands.remote.RenewBiasCommand buildRenewBiasCommand​(Object[] keys)
      • buildSingleKeyBackupWriteCommand

        org.infinispan.commands.triangle.SingleKeyBackupWriteCommand buildSingleKeyBackupWriteCommand()
      • buildSingleKeyFunctionalBackupWriteCommand

        org.infinispan.commands.triangle.SingleKeyFunctionalBackupWriteCommand buildSingleKeyFunctionalBackupWriteCommand()
      • buildPutMapBackupWriteCommand

        org.infinispan.commands.triangle.PutMapBackupWriteCommand buildPutMapBackupWriteCommand()
      • buildMultiEntriesFunctionalBackupWriteCommand

        org.infinispan.commands.triangle.MultiEntriesFunctionalBackupWriteCommand buildMultiEntriesFunctionalBackupWriteCommand()
      • buildMultiKeyFunctionalBackupWriteCommand

        org.infinispan.commands.triangle.MultiKeyFunctionalBackupWriteCommand buildMultiKeyFunctionalBackupWriteCommand()
      • buildBackupNoopCommand

        org.infinispan.commands.triangle.BackupNoopCommand buildBackupNoopCommand()
      • buildKeyReductionPublisherCommand

        <K,​R> org.infinispan.reactive.publisher.impl.commands.reduction.ReductionPublisherRequestCommand<K> buildKeyReductionPublisherCommand​(boolean parallelStream,
                                                                                                                                                    DeliveryGuarantee deliveryGuarantee,
                                                                                                                                                    IntSet segments,
                                                                                                                                                    Set<K> keys,
                                                                                                                                                    Set<K> excludedKeys,
                                                                                                                                                    long explicitFlags,
                                                                                                                                                    Function<? super org.reactivestreams.Publisher<K>,​? extends CompletionStage<R>> transformer,
                                                                                                                                                    Function<? super org.reactivestreams.Publisher<R>,​? extends CompletionStage<R>> finalizer)
      • buildEntryReductionPublisherCommand

        <K,​V,​R> org.infinispan.reactive.publisher.impl.commands.reduction.ReductionPublisherRequestCommand<K> buildEntryReductionPublisherCommand​(boolean parallelStream,
                                                                                                                                                              DeliveryGuarantee deliveryGuarantee,
                                                                                                                                                              IntSet segments,
                                                                                                                                                              Set<K> keys,
                                                                                                                                                              Set<K> excludedKeys,
                                                                                                                                                              long explicitFlags,
                                                                                                                                                              Function<? super org.reactivestreams.Publisher<CacheEntry<K,​V>>,​? extends CompletionStage<R>> transformer,
                                                                                                                                                              Function<? super org.reactivestreams.Publisher<R>,​? extends CompletionStage<R>> finalizer)
      • buildInitialPublisherCommand

        <K,​I,​R> org.infinispan.reactive.publisher.impl.commands.batch.InitialPublisherCommand<K,​I,​R> buildInitialPublisherCommand​(String requestId,
                                                                                                                                                          DeliveryGuarantee deliveryGuarantee,
                                                                                                                                                          int batchSize,
                                                                                                                                                          IntSet segments,
                                                                                                                                                          Set<K> keys,
                                                                                                                                                          Set<K> excludedKeys,
                                                                                                                                                          long explicitFlags,
                                                                                                                                                          boolean entryStream,
                                                                                                                                                          boolean trackKeys,
                                                                                                                                                          Function<? super org.reactivestreams.Publisher<I>,​? extends org.reactivestreams.Publisher<R>> transformer)
      • buildNextPublisherCommand

        org.infinispan.reactive.publisher.impl.commands.batch.NextPublisherCommand buildNextPublisherCommand​(String requestId)
      • buildCancelPublisherCommand

        org.infinispan.reactive.publisher.impl.commands.batch.CancelPublisherCommand buildCancelPublisherCommand​(String requestId)
      • buildCheckTransactionRpcCommand

        org.infinispan.commands.remote.CheckTransactionRpcCommand buildCheckTransactionRpcCommand​(Collection<GlobalTransaction> globalTransactions)
      • buildTouchCommand

        TouchCommand buildTouchCommand​(Object key,
                                       int segment,
                                       boolean touchEvenIfExpired,
                                       long flagBitSet)
      • buildIracClearKeysCommand

        org.infinispan.commands.irac.IracClearKeysCommand buildIracClearKeysCommand()
      • buildIracCleanupKeyCommand

        org.infinispan.commands.irac.IracCleanupKeysCommand buildIracCleanupKeyCommand​(Collection<? extends IracManagerKeyInfo> state)
      • buildIracTombstoneCleanupCommand

        org.infinispan.commands.irac.IracTombstoneCleanupCommand buildIracTombstoneCleanupCommand​(int maxCapacity)
      • buildIracMetadataRequestCommand

        org.infinispan.commands.irac.IracMetadataRequestCommand buildIracMetadataRequestCommand​(int segment,
                                                                                                IracEntryVersion versionSeen)
      • buildIracRequestStateCommand

        org.infinispan.commands.irac.IracRequestStateCommand buildIracRequestStateCommand​(IntSet segments)
      • buildIracStateResponseCommand

        org.infinispan.commands.irac.IracStateResponseCommand buildIracStateResponseCommand​(int capacity)
      • buildIracPutKeyValueCommand

        org.infinispan.commands.write.IracPutKeyValueCommand buildIracPutKeyValueCommand​(Object key,
                                                                                         int segment,
                                                                                         Object value,
                                                                                         Metadata metadata,
                                                                                         PrivateMetadata privateMetadata)
      • buildIracTouchCommand

        org.infinispan.commands.irac.IracTouchKeyCommand buildIracTouchCommand​(Object key)
      • buildIracUpdateVersionCommand

        org.infinispan.commands.irac.IracUpdateVersionCommand buildIracUpdateVersionCommand​(Map<Integer,​IracEntryVersion> segmentsVersion)
      • buildIracTombstoneRemoteSiteCheckCommand

        org.infinispan.commands.irac.IracTombstoneRemoteSiteCheckCommand buildIracTombstoneRemoteSiteCheckCommand​(List<Object> keys)
      • buildIracTombstoneStateResponseCommand

        org.infinispan.commands.irac.IracTombstoneStateResponseCommand buildIracTombstoneStateResponseCommand​(Collection<IracTombstoneInfo> state)
      • buildIracTombstonePrimaryCheckCommand

        org.infinispan.commands.irac.IracTombstonePrimaryCheckCommand buildIracTombstonePrimaryCheckCommand​(Collection<IracTombstoneInfo> tombstones)
      • buildIracPutManyCommand

        org.infinispan.commands.irac.IracPutManyCommand buildIracPutManyCommand​(int capacity)