Redis

abstract val host: String

abstract def onConnect(): Unit

abstract val port: Int

abstract val timeout: Int

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def asAny: Option[Any]

def asAnyMany(count: Int): List[Option[Any]]

def asBoolean: Boolean

def asBulk[T](implicit parse: Parse[T]): Option[T]

def asBulkWithTime[T](implicit parse: Parse[T]): Option[T]

def asExec(handlers: Seq[() ⇒ Any]): Option[List[Any]]

final def asInstanceOf[T0]: T0

def asInt: Option[Int]

def asList[T](implicit parse: Parse[T]): Option[List[Option[T]]]

def asListPairs[A, B](implicit parseA: Parse[A], parseB: Parse[B]): Option[List[Option[(A, B)]]]

def asListTrios[A, B](implicit parseA: Parse[A], parseB: Parse[B], format: Format): Option[List[Option[(A, B, Double)]]]

def asLong: Option[Long]

def asPair[T](implicit parse: Parse[T]): Option[(Option[Int], Option[List[Option[T]]])]

def asQueuedList: Option[List[Option[String]]]

def asSet[T](implicit arg0: Parse[T]): Option[Set[Option[T]]]

def asString: Option[String]

def bulkRead(s: Array[Byte]): Option[Array[Byte]]

val bulkReply: SingleReply

def clearFd(): Unit

def clone(): AnyRef

def cmd(args: Seq[Array[Byte]]): Array[Byte]

val commandBuffer: ListBuffer[CommandToSend]

def connect: Boolean

def connected: Boolean

var db: Int

def debug(message: String, error: Throwable): Unit

def debug(message: String, values: AnyRef*): Unit

def disconnect: Boolean

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

val errReply: Reply[Nothing]

def error(message: String, error: Throwable): Unit

def error(message: String, values: AnyRef*): Unit

def execReply(handlers: Seq[() ⇒ Any]): PartialFunction[(Char, Array[Byte]), Option[List[Any]]]

def flattenPairs(in: Iterable[Product2[Any, Any]]): List[Any]

val geoRadiusMemberReply: Reply[Option[List[Option[GeoRadiusMember]]]]

Entry point for GEORADIUS result analysis.

final def getClass(): Class[_]

var handlers: Vector[(String, () ⇒ Any)]

def hashCode(): Int

def ifDebug(message: ⇒ String): Unit

def ifError(message: ⇒ String): Unit

def ifInfo(message: ⇒ String): Unit

def ifTrace(message: ⇒ String): Unit

def ifWarn(message: ⇒ String): Unit

var in: InputStream

def info(message: String, error: Throwable): Unit

def info(message: String, values: AnyRef*): Unit

val integerReply: Reply[Option[Int]]

final def isInstanceOf[T0]: Boolean

val longReply: Reply[Option[Long]]

val multiBulkNested: MultiNestedReply

val multiBulkReply: MultiReply

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

var out: OutputStream

val pairBulkReply: PairReply

def queuedReplyInt: Reply[Option[Int]]

def queuedReplyList: MultiReply

def queuedReplyLong: Reply[Option[Long]]

def readCounted(count: Int): Array[Byte]

def readLine: Array[Byte]

def receive[T](pf: Reply[T]): T

def send[A](commands: List[CommandToSend])(result: ⇒ A): A

def send[A](command: String)(result: ⇒ A): A

def send[A](command: String, args: Seq[Any])(result: ⇒ A)(implicit format: Format): A

val singleLineReply: SingleReply

var socket: Socket

val sslContext: Option[SSLContext]

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

def toString(): String

def trace(message: String, error: Throwable): Unit

def trace(message: String, values: AnyRef*): Unit

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def warn(message: String, error: Throwable): Unit

def warn(message: String, values: AnyRef*): Unit

def write(data: Array[Byte]): Unit

def write_to_socket(data: Array[Byte])(op: (OutputStream) ⇒ Unit): Unit

def finalize(): Unit