class InfinispanProxyManager<K> extends AbstractProxyManager<K> {

    private final InfinispanProcessor<K, Void> REMOVE_BUCKET_ENTRY_PROCESSOR = new InfinispanProcessor<>(new byte[0]);
    private final ReadWriteMap<K, byte[]> readWriteMap;

    public InfinispanProxyManager(ReadWriteMap<K, byte[]> readWriteMap) {
        this(readWriteMap, ClientSideConfig.getDefault());
    }

    public InfinispanProxyManager(ReadWriteMap<K, byte[]> readWriteMap, ClientSideConfig clientSideConfig) {
        super(clientSideConfig);
        this.readWriteMap = Objects.requireNonNull(readWriteMap);
    }

    @Override
    public <T> CommandResult<T> execute(K key, Request<T> request) {<FILL_FUNCTION_BODY>}

    @Override
    public boolean isAsyncModeSupported() {
        return true;
    }

    @Override
    public void removeProxy(K key) {
        try {
            removeAsync(key).get();
        } catch (InterruptedException | ExecutionException e) {
            throw new CacheException(e);
        }
    }

    @Override
    protected CompletableFuture<Void> removeAsync(K key) {
        try {
            CompletableFuture<byte[]> resultFuture = readWriteMap.eval(key, REMOVE_BUCKET_ENTRY_PROCESSOR);
            return resultFuture.thenApply(resultBytes -> null);
        } catch (Throwable t) {
            CompletableFuture<Void> fail = new CompletableFuture<>();
            fail.completeExceptionally(t);
            return fail;
        }
    }

    @Override
    public <T> CompletableFuture<CommandResult<T>> executeAsync(K key, Request<T> request) {
        try {
            InfinispanProcessor<K, T> entryProcessor = new InfinispanProcessor<>(request);
            CompletableFuture<byte[]> resultFuture = readWriteMap.eval(key, entryProcessor);
            return resultFuture.thenApply(resultBytes -> deserializeResult(resultBytes, request.getBackwardCompatibilityVersion()));
        } catch (Throwable t) {
            CompletableFuture<CommandResult<T>> fail = new CompletableFuture<>();
            fail.completeExceptionally(t);
            return fail;
        }
    }


}

        InfinispanProcessor<K, T> entryProcessor = new InfinispanProcessor<>(request);
        try {
            CompletableFuture<byte[]> resultFuture = readWriteMap.eval(key, entryProcessor);
            return (CommandResult<T>) resultFuture.thenApply(resultBytes -> deserializeResult(resultBytes, request.getBackwardCompatibilityVersion())).get();
        } catch (InterruptedException | ExecutionException e) {
            throw new CacheException(e);
        }
    
<methods>public AsyncProxyManager<K> asAsync() ,public RemoteBucketBuilder<K> builder() ,public Optional<io.github.bucket4j.BucketConfiguration> getProxyConfiguration(K) <variables>private static final io.github.bucket4j.distributed.proxy.RecoveryStrategy DEFAULT_RECOVERY_STRATEGY,private static final io.github.bucket4j.distributed.proxy.optimization.Optimization DEFAULT_REQUEST_OPTIMIZER,private AsyncProxyManager<K> asyncView,private final non-sealed io.github.bucket4j.distributed.proxy.ClientSideConfig clientSideConfig