SimpleReplicationClient

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def adapt[T](bijection: Bijection[Buf, T]): BaseClient[T]

def add(key: String, flags: Int, expiry: Time, value: Buf): Future[Boolean]

Add a new key to all replicas, succeed only if all replicas succeed.

def add(key: String, value: Buf): Future[Boolean]

Store a key but only if it doesn't already exist on the server.

def append(key: String, flags: Int, expiry: Time, value: Buf): Future[Boolean]

Append bytes to the end of an existing key.

def append(key: String, value: Buf): Future[Boolean]

Append a set of bytes to the end of an existing key.

final def asInstanceOf[T0]: T0

def bufferToType(v: Buf): Buf

def checkAndSet(key: String, flags: Int, expiry: Time, value: Buf, casUnique: Buf): Future[CasResult]

Check and set a key, succeed only if all replicas succeed.

def checkAndSet(key: String, value: Buf, casUnique: Buf): Future[CasResult]

Perform a CAS operation on the key, only if the value has not changed since the value was last retrieved.

def clone(): AnyRef

def decr(key: String, delta: Long): Future[Option[Long]]

Decrease an existing key in all replicas, succeed only if all replicas succeed.

def decr(key: String): Future[Option[Long]]

def delete(key: String): Future[Boolean]

Delete a key from all replicas, succeed only if all replicas succeed.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def get(keys: Iterable[String]): Future[Map[String, Buf]]

Get a set of keys from the server.

def get(key: String): Future[Option[Buf]]

Get a key from the server.

final def getClass(): Class[_]

def getResult(keys: Iterable[String]): Future[GetResult]

Returns the first result found within all replicas, or miss/failure depends on the last replica

def gets(keys: Iterable[String]): Future[Map[String, (Buf, Buf)]]

Get a set of keys from the server, together with a "cas unique" token.

def gets(key: String): Future[Option[(Buf, Buf)]]

Get a key from the server, with a "cas unique" token.

def getsResult(keys: Iterable[String]): Future[GetsResult]

Only returns the consistent result from all replicas; if the data is inconsistent, this client simply returns nothing just like key missing; if any failure occurs, this method returns failure as there's a great chance the check-and-set won't succeed.

def hashCode(): Int

def incr(key: String, delta: Long): Future[Option[Long]]

Increase an existing key in all replicas, succeed only if all replicas succeed.

def incr(key: String): Future[Option[Long]]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prepend(key: String, flags: Int, expiry: Time, value: Buf): Future[Boolean]

Prepend bytes to the beginning of an existing key.

def prepend(key: String, value: Buf): Future[Boolean]

Prepend a set of bytes to the beginning of an existing key.

def quit(): Future[Unit]

Send a quit command to the server.

def release(): Unit

release the underlying service(s)

def replace(key: String, flags: Int, expiry: Time, value: Buf): Future[Boolean]

Replace an existing key in all replicas, succeed only if all replicas succeed.

def replace(key: String, value: Buf): Future[Boolean]

Replace an item if it exists.

def set(key: String, flags: Int, expiry: Time, value: Buf): Future[Unit]

Store a key in all replicas, succeed only if all replicas succeed.

def set(key: String, value: Buf): Future[Unit]

Store a key.

def stats(args: Option[String]): Future[Seq[String]]

Send a stats command with optional arguments to the server

def stats(): Future[Seq[String]]

def stats(args: String): Future[Seq[String]]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withBytes: BaseClient[Array[Byte]]

Adaptor to use Array[Byte] as values

def withStrings: BaseClient[String]

Adaptor to use String as values

final def cas(key: String, value: Buf, casUnique: Buf): Future[Boolean]

Perform a CAS operation on the key, only if the value has not changed since the value was last retrieved, and casUnique extracted from a gets command.

final def cas(key: String, flags: Int, expiry: Time, value: Buf, casUnique: Buf): Future[Boolean]

Perform a CAS operation on the key, only if the value has not changed since the value was last retrieved, and casUnique extracted from a gets command.