How to use org.infinispan.configuration.cache

@Override
public AsyncStoreConfiguration get() {
  return new ConfigurationBuilder().persistence().addSingleFileStore().async()
      .modificationQueueSize(this.queueSize)
      .threadPoolSize(this.poolSize)
      .create();
}

  @Override
  public AsyncStoreConfiguration get() {
    return new ConfigurationBuilder().persistence().addSingleFileStore().async().disable().create();
  }
}

@Override
public StateTransferConfiguration get() {
  boolean timeoutEnabled = this.timeout > 0;
  return new ConfigurationBuilder().clustering().stateTransfer()
      .chunkSize(this.chunkSize)
      .fetchInMemoryState(true)
      .awaitInitialTransfer(timeoutEnabled)
      .timeout(timeoutEnabled ? this.timeout : Long.MAX_VALUE)
      .create();
}

public InfinispanCacheProperties(Configuration config) {
  this.transactional = config.transaction().transactionMode().isTransactional();
  this.lockOnWrite = this.transactional && (config.transaction().lockingMode() == LockingMode.PESSIMISTIC);
  this.lockOnRead = this.lockOnWrite && (config.locking().isolationLevel() == IsolationLevel.REPEATABLE_READ);
  boolean clustered = config.clustering().cacheMode().needsStateTransfer();
  boolean hasStore = config.persistence().usingStores();
  this.marshalling = clustered || hasStore;
  this.persistent = clustered || (hasStore && !config.persistence().passivation());
}

  @Override
  public ExpirationConfiguration get() {
    return new ConfigurationBuilder().expiration()
        .wakeUpInterval(this.interval)
        .lifespan(this.lifespan)
        .maxIdle(this.maxIdle)
        .create();
  }
}

  @Override
  public MemoryConfiguration get() {
    return new ConfigurationBuilder().memory()
        .size(this.size)
        .storageType(this.storageType)
        .evictionStrategy(this.size > 0 ? EvictionStrategy.REMOVE : EvictionStrategy.MANUAL)
        .evictionType(this.evictionType)
        .addressCount(this.capacity)
        .create();
  }
}

@Override
public LockingConfiguration get() {
  return new ConfigurationBuilder().locking()
      .lockAcquisitionTimeout(this.timeout)
      .concurrencyLevel(this.concurrency)
      .isolationLevel(this.isolation)
      .useLockStriping(this.striping)
      .create();
}

@Override
public PartitionHandlingConfiguration get() {
  return new ConfigurationBuilder().clustering().partitionHandling()
      .whenSplit(this.enabled ? PartitionHandling.DENY_READ_WRITES : PartitionHandling.ALLOW_READ_WRITES)
      .mergePolicy(MergePolicy.NONE)
      .create();
}

  @Override
  public PersistenceConfiguration get() {
    return new ConfigurationBuilder().persistence().passivation(false).create();
  }
}

  public static <K, V> DataContainer<K, V> createDataContainer(ConfigurationBuilder builder, long size, Predicate<K> evictable) {
    EntrySizeCalculator<? super K, ? super InternalCacheEntry<K, V>> calculator = (key, entry) -> evictable.test(key) ? 1 : 0;
    return builder.clustering().cacheMode().needsStateTransfer() ? new BoundedSegmentedDataContainer<>(builder.clustering().hash().create().numSegments(), size, calculator) : new EvictableDataContainer<>(size, calculator);
  }
}

  @Override
  public void accept(ConfigurationBuilder builder) {
    super.accept(builder);

    builder.clustering().cacheMode(CacheMode.LOCAL);

    // Auto-enable simple cache optimization if cache is non-transactional and non-persistent
    builder.simpleCache((this.memory().storageType() == StorageType.OBJECT) && !this.transaction().transactionMode().isTransactional() && !this.persistence().usingStores());
  }
}

  @Override
  public SitesConfiguration get() {
    SitesConfigurationBuilder builder = new ConfigurationBuilder().sites();
    builder.disableBackups(this.backups.isEmpty());
    for (Map.Entry<String, BackupConfiguration> backup : this.backups.entrySet()) {
      builder.addBackup().read(backup.getValue());
      builder.addInUseBackupSite(backup.getKey());
    }
    return builder.create();
  }
}

  @Override
  public void accept(ConfigurationBuilder builder) {
    super.accept(builder);

    builder.clustering()
        .hash().capacityFactor(this.capacityFactor).numOwners(this.owners)
        .l1().enabled(this.l1Lifespan > 0).lifespan(this.l1Lifespan)
        ;
  }
}

  @Override
  public void accept(ConfigurationBuilder builder) {
    builder.clustering()
        .cacheMode(this.mode)
        .remoteTimeout(this.remoteTimeout, TimeUnit.MILLISECONDS)
        ;
    super.accept(builder);
  }
}

  @Override
  public void accept(ConfigurationBuilder builder) {
    super.accept(builder);

    builder.clustering().partitionHandling().read(this.partitionHandling.get());
    builder.clustering().stateTransfer().read(this.stateTransfer.get());

    SitesConfigurationBuilder sitesBuilder = builder.sites();
    sitesBuilder.read(this.backups.get());
  }
}

@Override
public void accept(ConfigurationBuilder builder) {
  super.accept(builder);
  builder.clustering()
      .biasAcquisition((this.biasLifespan > 0) ? BiasAcquisition.ON_WRITE : BiasAcquisition.NEVER)
      .biasLifespan(this.biasLifespan, TimeUnit.MILLISECONDS)
      .invalidationBatchSize(this.invalidationBatchSize)
      ;
}

@SuppressWarnings("deprecation")
@Override
public HotRodStoreConfiguration create() {
  return new HotRodStoreConfiguration(this.attributes.protect(), this.async.create(), this.singletonStore.create());
}

public static Mode forCacheMode(CacheMode mode) {
  return mode.isSynchronous() ? SYNC : ASYNC;
}

public CacheMode apply(CacheMode mode) {
  return this.sync ? mode.toSync() : mode.toAsync();
}

ClusteredCacheServiceConfigurator(PathAddress address, CacheMode mode) {
  super(address);
  this.mode = mode.toSync();
}