All Downloads are FREE. Search and download functionalities are using the official Maven repository.

net.spy.memcached.ArcusClientPool Maven / Gradle / Ivy

/*
 * arcus-java-client : Arcus Java client
 * Copyright 2010-2014 NAVER Corp.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.spy.memcached;

import java.net.SocketAddress;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

import net.spy.memcached.collection.Attributes;
import net.spy.memcached.collection.BTreeGetResult;
import net.spy.memcached.collection.BTreeOrder;
import net.spy.memcached.collection.ByteArrayBKey;
import net.spy.memcached.collection.CollectionAttributes;
import net.spy.memcached.collection.CollectionOverflowAction;
import net.spy.memcached.collection.CollectionPipedStore;
import net.spy.memcached.collection.Element;
import net.spy.memcached.collection.ElementFlagFilter;
import net.spy.memcached.collection.ElementFlagUpdate;
import net.spy.memcached.collection.ElementValueType;
import net.spy.memcached.collection.SMGetElement;
import net.spy.memcached.collection.SMGetMode;
import net.spy.memcached.internal.BTreeStoreAndGetFuture;
import net.spy.memcached.internal.BulkFuture;
import net.spy.memcached.internal.CollectionFuture;
import net.spy.memcached.internal.CollectionGetBulkFuture;
import net.spy.memcached.internal.OperationFuture;
import net.spy.memcached.internal.SMGetFuture;
import net.spy.memcached.ops.CollectionOperationStatus;
import net.spy.memcached.transcoders.Transcoder;

/**
 * Bags for ArcusClient
 */
public class ArcusClientPool implements ArcusClientIF {

	int poolSize;
	ArcusClient[] client;
	Random rand;

	public ArcusClientPool(int poolSize, ArcusClient[] client) {

		this.poolSize = poolSize;
		this.client = client;
		rand = new Random();
	}

	/**
	 * Returns single ArcusClient
	 * 
	 * @return ArcusClient
	 */
	public ArcusClient getClient() {
		return client[rand.nextInt(poolSize)];
	}

	/**
	 * Returns all ArcusClient in pool
	 * 
	 * @return ArcusClient array
	 */
	public ArcusClient[] getAllClients() {
		return client;
	}

	public void shutdown() {
		for (ArcusClient ac : client) {
			ac.shutdown();
		}
	}

	public Future append(long cas, String key, Object val) {
		return this.getClient().append(cas, key, val);
	}

	public  Future append(long cas, String key, T val,
			Transcoder tc) {
		return this.getClient().append(cas, key, val, tc);
	}

	public Future prepend(long cas, String key, Object val) {
		return this.getClient().prepend(cas, key, val);
	}

	public  Future prepend(long cas, String key, T val,
			Transcoder tc) {
		return this.getClient().prepend(cas, key, val, tc);
	}

	public  Future asyncCAS(String key, long casId, T value,
			Transcoder tc) {
		return this.getClient().asyncCAS(key, casId, value, tc);
	}

	public Future asyncCAS(String key, long casId, Object value) {

		return this.getClient().asyncCAS(key, casId, value);
	}

	public  CASResponse cas(String key, long casId, T value, Transcoder tc)
			throws OperationTimeoutException {
		return this.getClient().cas(key, casId, value, tc);
	}

	public CASResponse cas(String key, long casId, Object value)
			throws OperationTimeoutException {
		return this.getClient().cas(key, casId, value);
	}

	public  Future add(String key, int exp, T o, Transcoder tc) {
		return this.getClient().add(key, exp, o, tc);
	}

	public Future add(String key, int exp, Object o) {
		return this.getClient().add(key, exp, o);
	}

	public  Future set(String key, int exp, T o, Transcoder tc) {
		return this.getClient().set(key, exp, o, tc);
	}

	public Future set(String key, int exp, Object o) {
		return this.getClient().set(key, exp, o);
	}

	public  Future replace(String key, int exp, T o,
			Transcoder tc) {
		return this.getClient().replace(key, exp, o, tc);
	}

	public Future replace(String key, int exp, Object o) {
		return this.getClient().replace(key, exp, o);
	}

	public  Future asyncGet(String key, Transcoder tc) {
		return this.getClient().asyncGet(key, tc);
	}

	public Future asyncGet(String key) {
		return this.getClient().asyncGet(key);
	}

	public  Future> asyncGets(String key, Transcoder tc) {
		return this.getClient().asyncGets(key, tc);
	}

	public Future> asyncGets(String key) {
		return this.getClient().asyncGets(key);
	}

	public  CASValue gets(String key, Transcoder tc)
			throws OperationTimeoutException {
		return this.getClient().gets(key, tc);
	}

	public CASValue gets(String key) throws OperationTimeoutException {
		return this.getClient().gets(key);
	}

	public  T get(String key, Transcoder tc)
			throws OperationTimeoutException {
		return this.getClient().get(key, tc);
	}

	public Object get(String key) throws OperationTimeoutException {
		return this.getClient().get(key);
	}

	public  BulkFuture> asyncGetBulk(Collection keys,
			Iterator> tcs) {
		return this.getClient().asyncGetBulk(keys, tcs);
	}

	public  BulkFuture> asyncGetBulk(Collection keys,
			Transcoder tc) {
		return this.getClient().asyncGetBulk(keys, tc);
	}

	public BulkFuture> asyncGetBulk(Collection keys) {
		return this.getClient().asyncGetBulk(keys);
	}

	public  BulkFuture> asyncGetBulk(Transcoder tc,
			String... keys) {
		return this.getClient().asyncGetBulk(tc, keys);
	}

	public BulkFuture> asyncGetBulk(String... keys) {
		return this.getClient().asyncGetBulk(keys);
	}

	public  Map getBulk(Collection keys, Transcoder tc)
			throws OperationTimeoutException {
		return this.getClient().getBulk(keys, tc);
	}

	public Map getBulk(Collection keys)
			throws OperationTimeoutException {
		return this.getClient().getBulk(keys);
	}

	public  Map getBulk(Transcoder tc, String... keys)
			throws OperationTimeoutException {
		return this.getClient().getBulk(tc, keys);
	}

	public Map getBulk(String... keys)
			throws OperationTimeoutException {
		return this.getClient().getBulk(keys);
	}

	public Map getVersions() {
		return this.getClient().getVersions();
	}

	public Map> getStats() {
		return this.getClient().getStats();
	}

	public Map> getStats(String prefix) {
		return this.getClient().getStats(prefix);
	}

	public long incr(String key, int by) throws OperationTimeoutException {
		return this.getClient().incr(key, by);
	}

	public long decr(String key, int by) throws OperationTimeoutException {
		return this.getClient().decr(key, by);
	}

	public long incr(String key, int by, long def)
			throws OperationTimeoutException {
		return this.getClient().incr(key, by, def);
	}
	
	public long incr(String key, int by, long def, int exp)
			throws OperationTimeoutException {
		return this.getClient().incr(key, by, def, exp);
	}

	public long decr(String key, int by, long def)
			throws OperationTimeoutException {
		return this.getClient().decr(key, by, def);
	}
	
	public long decr(String key, int by, long def, int exp)
			throws OperationTimeoutException {
		return this.getClient().decr(key, by, def, exp);
	}

	public Future asyncIncr(String key, int by) {
		return this.getClient().asyncIncr(key, by);
	}
	
	public Future asyncIncr(String key, int by, long def, int exp) {
		return this.getClient().asyncIncr(key, by, def, exp);
	}

	public Future asyncDecr(String key, int by) {
		return this.getClient().asyncDecr(key, by);
	}
	
	public Future asyncDecr(String key, int by, long def, int exp) {
		return this.getClient().asyncDecr(key, by, def, exp);
	}

	public Future delete(String key) {
		return this.getClient().delete(key);
	}

	public Future flush(int delay) {
		return this.getClient().flush(delay);
	}

	public Future flush() {
		return this.getClient().flush();
	}

	public boolean waitForQueues(long timeout, TimeUnit unit) {
		return this.getClient().waitForQueues(timeout, unit);
	}

	public boolean addObserver(ConnectionObserver obs) {
		return this.getClient().addObserver(obs);
	}

	public boolean removeObserver(ConnectionObserver obs) {
		return this.getClient().removeObserver(obs);
	}

	public Set listSaslMechanisms() {
		return this.getClient().listSaslMechanisms();
	}

	@Override
	public CollectionFuture asyncSetAttr(String key, Attributes attrs) {
		return this.getClient().asyncSetAttr(key, attrs);
	}

	@Override
	public CollectionFuture asyncGetAttr(String key) {
		return this.getClient().asyncGetAttr(key);
	}

	@Override
	public  CollectionFuture asyncSopExist(String key, T value,
			Transcoder tc) {
		return this.getClient().asyncSopExist(key, value, tc);
	}

	@Override
	public CollectionFuture asyncSopExist(String key, Object value) {
		return this.getClient().asyncSopExist(key, value);
	}

	@Override
	public  Future> asyncSetBulk(
			List key, int exp, T o, Transcoder tc) {
		return this.getClient().asyncSetBulk(key, exp, o, tc);
	}

	@Override
	public Future> asyncSetBulk(
			List key, int exp, Object o) {
		return this.getClient().asyncSetBulk(key, exp, o);
	}

	@Override
	public  Future> asyncSetBulk(
			Map o, int exp, Transcoder tc) {
		return this.getClient().asyncSetBulk(o, exp, tc);
	}

	@Override
	public Future> asyncSetBulk(
			Map o, int exp) {
		return this.getClient().asyncSetBulk(o, exp);
	}

	@Override
	public  Future> asyncBopInsertBulk(
			List keyList, long bkey, byte[] eFlag, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopInsertBulk(keyList, bkey, eFlag, value,
				attributesForCreate, tc);
	}

	@Override
	public Future> asyncBopInsertBulk(
			List keyList, long bkey, byte[] eFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopInsertBulk(keyList, bkey, eFlag, value,
				attributesForCreate);
	}

	@Override
	public  Future> asyncLopInsertBulk(
			List keyList, int index, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncLopInsertBulk(keyList, index, value,
				attributesForCreate, tc);
	}

	@Override
	public Future> asyncLopInsertBulk(
			List keyList, int index, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncLopInsertBulk(keyList, index, value,
				attributesForCreate);
	}

	@Override
	public  Future> asyncSopInsertBulk(
			List keyList, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncSopInsertBulk(keyList, value,
				attributesForCreate, tc);
	}

	@Override
	public Future> asyncSopInsertBulk(
			List keyList, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncSopInsertBulk(keyList, value,
				attributesForCreate);
	}

	@Override
	public int getMaxPipedItemCount() {
		return CollectionPipedStore.MAX_PIPED_ITEM_COUNT;
	}

	@Override
	public CollectionFuture asyncBopCreate(String key,
			ElementValueType valueType, CollectionAttributes attributes) {
		return this.getClient().asyncBopCreate(key, valueType, attributes);
	}

	@Override
	public CollectionFuture asyncSopCreate(String key,
			ElementValueType type, CollectionAttributes attributes) {
		return this.getClient().asyncSopCreate(key, type, attributes);
	}

	@Override
	public CollectionFuture asyncLopCreate(String key,
			ElementValueType type, CollectionAttributes attributes) {
		return this.getClient().asyncLopCreate(key, type, attributes);
	}

	@Override
	public CollectionFuture>> asyncBopGet(String key,
			long bkey, ElementFlagFilter eFlagFilter, boolean withDelete,
			boolean dropIfEmpty) {
		return this.getClient().asyncBopGet(key, bkey, eFlagFilter, withDelete,
				dropIfEmpty);
	}

	@Override
	public CollectionFuture>> asyncBopGet(String key,
			long from, long to, ElementFlagFilter eFlagFilter, int offset,
			int count, boolean withDelete, boolean dropIfEmpty) {
		return this.getClient().asyncBopGet(key, from, to, eFlagFilter, offset,
				count, withDelete, dropIfEmpty);
	}

	@Override
	public  CollectionFuture>> asyncBopGet(String key,
			long bkey, ElementFlagFilter eFlagFilter, boolean withDelete,
			boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncBopGet(key, bkey, eFlagFilter, withDelete,
				dropIfEmpty, tc);
	}

	@Override
	public  CollectionFuture>> asyncBopGet(String key,
			long from, long to, ElementFlagFilter eFlagFilter, int offset,
			int count, boolean withDelete, boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncBopGet(key, from, to, eFlagFilter, offset,
				count, withDelete, dropIfEmpty, tc);
	}

	@Override
	public CollectionFuture> asyncLopGet(String key, int index,
			boolean withDelete, boolean dropIfEmpty) {
		return this.getClient()
				.asyncLopGet(key, index, withDelete, dropIfEmpty);
	}

	@Override
	public CollectionFuture> asyncLopGet(String key, int from,
			int to, boolean withDelete, boolean dropIfEmpty) {
		return this.getClient().asyncLopGet(key, from, to, withDelete,
				dropIfEmpty);
	}

	@Override
	public  CollectionFuture> asyncLopGet(String key, int index,
			boolean withDelete, boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncLopGet(key, index, withDelete,
				dropIfEmpty, tc);
	}

	@Override
	public  CollectionFuture> asyncLopGet(String key, int from,
			int to, boolean withDelete, boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncLopGet(key, from, to, withDelete,
				dropIfEmpty, tc);
	}

	@Override
	public CollectionFuture> asyncSopGet(String key, int count,
			boolean withDelete, boolean dropIfEmpty) {
		return this.getClient()
				.asyncSopGet(key, count, withDelete, dropIfEmpty);
	}

	@Override
	public  CollectionFuture> asyncSopGet(String key, int count,
			boolean withDelete, boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncSopGet(key, count, withDelete,
				dropIfEmpty, tc);
	}

	@Override
	public CollectionFuture asyncBopDelete(String key, long bkey,
			ElementFlagFilter eFlagFilter, boolean dropIfEmpty) {
		return this.getClient().asyncBopDelete(key, bkey, eFlagFilter,
				dropIfEmpty);
	}

	@Override
	public CollectionFuture asyncBopDelete(String key, long from,
			long to, ElementFlagFilter eFlagFilter, int count,
			boolean dropIfEmpty) {
		return this.getClient().asyncBopDelete(key, from, to, eFlagFilter,
				count, dropIfEmpty);
	}

	@Override
	public CollectionFuture asyncLopDelete(String key, int index,
			boolean dropIfEmpty) {
		return this.getClient().asyncLopDelete(key, index, dropIfEmpty);
	}

	@Override
	public CollectionFuture asyncLopDelete(String key, int from,
			int to, boolean dropIfEmpty) {
		return this.getClient().asyncLopDelete(key, from, to, dropIfEmpty);
	}

	@Override
	public CollectionFuture asyncSopDelete(String key, Object value,
			boolean dropIfEmpty) {
		return this.getClient().asyncSopDelete(key, value, dropIfEmpty);
	}

	@Override
	public  CollectionFuture asyncSopDelete(String key, T value,
			boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncSopDelete(key, value, dropIfEmpty, tc);
	}

	@Override
	public CollectionFuture asyncBopGetItemCount(String key,
			long from, long to, ElementFlagFilter eFlagFilter) {
		return this.getClient()
				.asyncBopGetItemCount(key, from, to, eFlagFilter);
	}

	@Override
	public CollectionFuture asyncBopInsert(String key, long bkey,
			byte[] eFlag, Object value, CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopInsert(key, bkey, eFlag, value,
				attributesForCreate);
	}

	@Override
	public CollectionFuture asyncLopInsert(String key, int index,
			Object value, CollectionAttributes attributesForCreate) {
		return this.getClient().asyncLopInsert(key, index, value,
				attributesForCreate);
	}

	@Override
	public CollectionFuture asyncSopInsert(String key, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncSopInsert(key, value, attributesForCreate);
	}

	@Override
	public  CollectionFuture asyncBopInsert(String key, long bkey,
			byte[] eFlag, T value, CollectionAttributes attributesForCreate,
			Transcoder tc) {
		return this.getClient().asyncBopInsert(key, bkey, eFlag, value,
				attributesForCreate);
	}

	@Override
	public  CollectionFuture asyncLopInsert(String key, int index,
			T value, CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncLopInsert(key, index, value,
				attributesForCreate, tc);
	}

	@Override
	public  CollectionFuture asyncSopInsert(String key, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncSopInsert(key, value, attributesForCreate,
				tc);
	}

	@Override
	public CollectionFuture> asyncBopPipedInsertBulk(
			String key, Map elements,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopPipedInsertBulk(key, elements,
				attributesForCreate);
	}

	@Override
	public CollectionFuture> asyncLopPipedInsertBulk(
			String key, int index, List valueList,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncLopPipedInsertBulk(key, index, valueList,
				attributesForCreate);
	}

	@Override
	public CollectionFuture> asyncSopPipedInsertBulk(
			String key, List valueList,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncSopPipedInsertBulk(key, valueList,
				attributesForCreate);
	}

	@Override
	public  CollectionFuture> asyncBopPipedInsertBulk(
			String key, Map elements,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopPipedInsertBulk(key, elements,
				attributesForCreate, tc);
	}

	@Override
	public  CollectionFuture> asyncLopPipedInsertBulk(
			String key, int index, List valueList,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncLopPipedInsertBulk(key, index, valueList,
				attributesForCreate, tc);
	}

	@Override
	public  CollectionFuture> asyncSopPipedInsertBulk(
			String key, List valueList,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncSopPipedInsertBulk(key, valueList,
				attributesForCreate, tc);
	}

	@Override
	public OperationFuture flush(String prefix) {
		return this.getClient().flush(prefix);
	}

	@Override
	public OperationFuture flush(String prefix, int delay) {
		return this.getClient().flush(prefix, delay);
	}

	@Override
	public SMGetFuture>> asyncBopSortMergeGet(
			List keyList, long from, long to,
			ElementFlagFilter eFlagFilter, int offset, int count) {
		return this.getClient().asyncBopSortMergeGet(keyList, from, to,
				eFlagFilter, offset, count);
	}

	@Override
	public SMGetFuture>> asyncBopSortMergeGet(
			List keyList, long from, long to,
			ElementFlagFilter eFlagFilter, int count, SMGetMode smgetMode) {
		return this.getClient().asyncBopSortMergeGet(keyList, from, to,
				eFlagFilter, count, smgetMode);
	}

	@Override
	public CollectionFuture asyncBopUpsert(String key, long bkey,
			byte[] elementFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopUpsert(key, bkey, elementFlag, value,
				attributesForCreate);
	}

	@Override
	public  CollectionFuture asyncBopUpsert(String key, long bkey,
			byte[] elementFlag, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopUpsert(key, bkey, elementFlag, value,
				attributesForCreate, tc);
	}

	@Override
	public CollectionFuture asyncBopInsert(String key, byte[] bkey,
			byte[] eFlag, Object value, CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopInsert(key, bkey, eFlag, value,
				attributesForCreate);
	}

	@Override
	public  CollectionFuture asyncBopInsert(String key,
			byte[] bkey, byte[] eFlag, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopInsert(key, bkey, eFlag, value,
				attributesForCreate, tc);
	}

	@Override
	public CollectionFuture>> asyncBopGet(
			String key, byte[] from, byte[] to, ElementFlagFilter eFlagFilter,
			int offset, int count, boolean withDelete, boolean dropIfEmpty) {
		return this.getClient().asyncBopGet(key, from, to, eFlagFilter, offset,
				count, withDelete, dropIfEmpty);
	}

	@Override
	public  CollectionFuture>> asyncBopGet(
			String key, byte[] from, byte[] to, ElementFlagFilter eFlagFilter,
			int offset, int count, boolean withDelete, boolean dropIfEmpty,
			Transcoder tc) {
		return this.getClient().asyncBopGet(key, from, to, eFlagFilter, offset,
				count, withDelete, dropIfEmpty, tc);
	}

	@Override
	public CollectionFuture asyncBopDelete(String key, byte[] from,
			byte[] to, ElementFlagFilter eFlagFilter, int count,
			boolean dropIfEmpty) {
		return this.getClient().asyncBopDelete(key, from, to, eFlagFilter,
				count, dropIfEmpty);
	}

	@Override
	public CollectionFuture asyncBopDelete(String key, byte[] bkey,
			ElementFlagFilter eFlagFilter, boolean dropIfEmpty) {
		return this.getClient().asyncBopDelete(key, bkey, eFlagFilter,
				dropIfEmpty);
	}

	@Override
	public CollectionFuture asyncBopUpsert(String key, byte[] bkey,
			byte[] elementFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopUpsert(key, bkey, elementFlag, value,
				attributesForCreate);
	}

	@Override
	public  CollectionFuture asyncBopUpsert(String key,
			byte[] bkey, byte[] elementFlag, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopUpsert(key, bkey, elementFlag, value,
				attributesForCreate, tc);
	}

	@Override
	public CollectionFuture asyncBopGetItemCount(String key,
			byte[] from, byte[] to, ElementFlagFilter eFlagFilter) {
		return this.getClient()
				.asyncBopGetItemCount(key, from, to, eFlagFilter);
	}

	@Override
	public CollectionFuture asyncBopUpdate(String key, long bkey,
			ElementFlagUpdate eFlagUpdate, Object value) {
		return this.getClient().asyncBopUpdate(key, bkey, eFlagUpdate, value);
	}

	@Override
	public  CollectionFuture asyncBopUpdate(String key, long bkey,
			ElementFlagUpdate eFlagUpdate, T value, Transcoder tc) {
		return this.getClient().asyncBopUpdate(key, bkey, eFlagUpdate, value,
				tc);
	}

	@Override
	public CollectionFuture asyncBopUpdate(String key, byte[] bkey,
			ElementFlagUpdate eFlagUpdate, Object value) {
		return this.getClient().asyncBopUpdate(key, bkey, eFlagUpdate, value);
	}

	@Override
	public  CollectionFuture asyncBopUpdate(String key,
			byte[] bkey, ElementFlagUpdate eFlagUpdate, T value,
			Transcoder tc) {
		return this.getClient().asyncBopUpdate(key, bkey, eFlagUpdate, value,
				tc);
	}

	@Override
	public CollectionFuture> asyncBopPipedUpdateBulk(
			String key, List> elements) {
		return this.getClient().asyncBopPipedUpdateBulk(key, elements);
	}

	@Override
	public  CollectionFuture> asyncBopPipedUpdateBulk(
			String key, List> elements, Transcoder tc) {
		return this.getClient().asyncBopPipedUpdateBulk(key, elements, tc);
	}

	@Override
	public CollectionFuture> asyncSopPipedExistBulk(
			String key, List values) {
		return this.getClient().asyncSopPipedExistBulk(key, values);
	}

	@Override
	public  CollectionFuture> asyncSopPipedExistBulk(
			String key, List values, Transcoder tc) {
		return this.getClient().asyncSopPipedExistBulk(key, values, tc);
	}

	@Override
	public CollectionFuture> asyncBopPipedInsertBulk(
			String key, List> elements,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopPipedInsertBulk(key, elements,
				attributesForCreate);
	}

	@Override
	public  CollectionFuture> asyncBopPipedInsertBulk(
			String key, List> elements,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopPipedInsertBulk(key, elements,
				attributesForCreate, tc);
	}

	@Override
	public CollectionFuture>> asyncBopGet(
			String key, byte[] bkey, ElementFlagFilter eFlagFilter,
			boolean withDelete, boolean dropIfEmpty) {
		return this.getClient().asyncBopGet(key, bkey, eFlagFilter, withDelete,
				dropIfEmpty);
	}

	@Override
	public  CollectionFuture>> asyncBopGet(
			String key, byte[] bkey, ElementFlagFilter eFlagFilter,
			boolean withDelete, boolean dropIfEmpty, Transcoder tc) {
		return this.getClient().asyncBopGet(key, bkey, eFlagFilter, withDelete,
				dropIfEmpty, tc);
	}

	@Override
	public SMGetFuture>> asyncBopSortMergeGet(
			List keyList, byte[] from, byte[] to,
			ElementFlagFilter eFlagFilter, int offset, int count) {
		return this.getClient().asyncBopSortMergeGet(keyList, from, to,
				eFlagFilter, offset, count);
	}

	@Override
	public SMGetFuture>> asyncBopSortMergeGet(
			List keyList, byte[] from, byte[] to,
			ElementFlagFilter eFlagFilter, int count, SMGetMode smgetMode) {
		return this.getClient().asyncBopSortMergeGet(keyList, from, to,
				eFlagFilter, count, smgetMode);
	}

	@Override
	public Future> asyncBopInsertBulk(
			List keyList, byte[] bkey, byte[] eFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopInsertBulk(keyList, bkey, eFlag, value,
				attributesForCreate);
	}

	@Override
	public  Future> asyncBopInsertBulk(
			List keyList, byte[] bkey, byte[] eFlag, T value,
			CollectionAttributes attributesForCreate, Transcoder tc) {
		return this.getClient().asyncBopInsertBulk(keyList, bkey, eFlag, value,
				attributesForCreate, tc);
	}

	@Override
	public CollectionGetBulkFuture>> asyncBopGetBulk(
			List keyList, byte[] from, byte[] to,
			ElementFlagFilter eFlagFilter, int offset, int count) {
		return this.getClient().asyncBopGetBulk(keyList, from, to, eFlagFilter,
				offset, count);
	}

	@Override
	public  CollectionGetBulkFuture>> asyncBopGetBulk(
			List keyList, byte[] from, byte[] to,
			ElementFlagFilter eFlagFilter, int offset, int count,
			Transcoder tc) {
		return this.getClient().asyncBopGetBulk(keyList, from, to, eFlagFilter,
				offset, count, tc);
	}

	@Override
	public CollectionGetBulkFuture>> asyncBopGetBulk(
			List keyList, long from, long to,
			ElementFlagFilter eFlagFilter, int offset, int count) {
		return this.getClient().asyncBopGetBulk(keyList, from, to, eFlagFilter,
				offset, count);
	}

	@Override
	public  CollectionGetBulkFuture>> asyncBopGetBulk(
			List keyList, long from, long to,
			ElementFlagFilter eFlagFilter, int offset, int count,
			Transcoder tc) {
		return this.getClient().asyncBopGetBulk(keyList, from, to, eFlagFilter,
				offset, count, tc);
	}

	@Override
	public CollectionFuture asyncBopIncr(String key, long subkey, int by) {
		return this.getClient().asyncBopIncr(key, subkey, by);
	}

	@Override
	public CollectionFuture asyncBopIncr(String key, byte[] subkey, int by) {
		return this.getClient().asyncBopIncr(key, subkey, by);
	}

	@Override
	public CollectionFuture asyncBopDecr(String key, long subkey, int by) {
		return this.getClient().asyncBopIncr(key, subkey, by);
	}

	@Override
	public CollectionFuture asyncBopDecr(String key, byte[] subkey, int by) {
		return this.getClient().asyncBopIncr(key, subkey, by);
	}

	@Override
	public CollectionFuture>> asyncBopGetByPosition(
			String key, BTreeOrder order, int pos) {
		return this.getClient().asyncBopGetByPosition(key, order, pos);
	}

	@Override
	public  CollectionFuture>> asyncBopGetByPosition(
			String key, BTreeOrder order, int pos, Transcoder tc) {
		return this.getClient().asyncBopGetByPosition(key, order, pos, tc);
	}

	@Override
	public CollectionFuture>> asyncBopGetByPosition(
			String key, BTreeOrder order, int from, int to) {
		return this.getClient().asyncBopGetByPosition(key, order, from, to);
	}

	@Override
	public  CollectionFuture>> asyncBopGetByPosition(
			String key, BTreeOrder order, int from, int to, Transcoder tc) {
		return this.getClient().asyncBopGetByPosition(key, order, from, to, tc);
	}

	@Override
	public CollectionFuture asyncBopFindPosition(String key,
			long longBKey, BTreeOrder order) {
		return this.getClient().asyncBopFindPosition(key, longBKey, order);
	}

	@Override
	public CollectionFuture asyncBopFindPosition(String key,
			byte[] byteArrayBKey, BTreeOrder order) {
		return this.getClient().asyncBopFindPosition(key, byteArrayBKey, order);
	}

	@Override
	public CollectionFuture>> asyncBopFindPositionWithGet(
			String key, long longBKey, BTreeOrder order, int count) {
		return this.getClient().asyncBopFindPositionWithGet(key, longBKey, order, count);
	}

	@Override
	public  CollectionFuture>> asyncBopFindPositionWithGet(
			String key, long longBKey, BTreeOrder order, int count, Transcoder tc) {
		return this.getClient().asyncBopFindPositionWithGet(key, longBKey, order, count, tc);
	}

	@Override
	public CollectionFuture>> asyncBopFindPositionWithGet(
			String key, byte[] byteArrayBKey, BTreeOrder order, int count) {
		return this.getClient().asyncBopFindPositionWithGet(key, byteArrayBKey, order, count);
	}

	@Override
	public  CollectionFuture>> asyncBopFindPositionWithGet(
			String key, byte[] byteArrayBKey, BTreeOrder order, int count, Transcoder tc) {
		return this.getClient().asyncBopFindPositionWithGet(key, byteArrayBKey, order, count, tc);
	}

	@Override
	public BTreeStoreAndGetFuture asyncBopInsertAndGetTrimmed(
			String key, long bkey, byte[] eFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopInsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate);
	}

	@Override
	public  BTreeStoreAndGetFuture asyncBopInsertAndGetTrimmed(
			String key, long bkey, byte[] eFlag, E value,
			CollectionAttributes attributesForCreate, Transcoder transcoder) {
		return this.getClient().asyncBopInsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate, transcoder);
	}

	@Override
	public BTreeStoreAndGetFuture asyncBopInsertAndGetTrimmed(
			String key, byte[] bkey, byte[] eFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopInsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate);
	}

	@Override
	public  BTreeStoreAndGetFuture asyncBopInsertAndGetTrimmed(
			String key, byte[] bkey, byte[] eFlag, E value,
			CollectionAttributes attributesForCreate, Transcoder transcoder) {
		return this.getClient().asyncBopInsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate, transcoder);
	}

	@Override
	public BTreeStoreAndGetFuture asyncBopUpsertAndGetTrimmed(
			String key, long bkey, byte[] eFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopUpsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate);
	}

	@Override
	public  BTreeStoreAndGetFuture asyncBopUpsertAndGetTrimmed(
			String key, long bkey, byte[] eFlag, E value,
			CollectionAttributes attributesForCreate, Transcoder transcoder) {
		return this.getClient().asyncBopUpsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate, transcoder);
	}

	@Override
	public BTreeStoreAndGetFuture asyncBopUpsertAndGetTrimmed(
			String key, byte[] bkey, byte[] eFlag, Object value,
			CollectionAttributes attributesForCreate) {
		return this.getClient().asyncBopUpsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate);
	}

	@Override
	public  BTreeStoreAndGetFuture asyncBopUpsertAndGetTrimmed(
			String key, byte[] bkey, byte[] eFlag, E value,
			CollectionAttributes attributesForCreate, Transcoder transcoder) {
		return this.getClient().asyncBopUpsertAndGetTrimmed(key, bkey, eFlag,
				value, attributesForCreate, transcoder);
	}

}