redis

package

Go to main page

Versions in this module

v0

v0.3.4

Oct 5, 2012

v0.3.3

Oct 2, 2012

v0.3.2

Sep 29, 2012

Changes in this version

type Config

+ Network string

v0.3.1

Aug 7, 2012

v0.3.0

Aug 3, 2012

Changes in this version

type Client

+ func (c *Client) AsyncBitcount(args ...interface{}) Future

+ func (c *Client) AsyncBitop(args ...interface{}) Future

+ func (c *Client) AsyncReplconf(args ...interface{}) Future

+ func (c *Client) Bitcount(args ...interface{}) *Reply

+ func (c *Client) Bitop(args ...interface{}) *Reply

+ func (c *Client) InfoMap() (map[string]string, error)

+ func (c *Client) Replconf(args ...interface{}) *Reply

type Config

+ Address string

+ Database int

+ Password string

+ Path string

+ PoolCapacity int

+ RetryLoading bool

+ Timeout time.Duration

+ func DefaultConfig() Config

type ErrorFlag

+ const ErrorInvalid

type MultiCall

+ func (mc *MultiCall) Bitcount(args ...interface{})

+ func (mc *MultiCall) Bitop(args ...interface{})

+ func (mc *MultiCall) Replconf(args ...interface{})

type Reply

+ Err *Error

+ func (r *Reply) Hash() (map[string]string, error)

+ func (r *Reply) List() ([]string, error)

v0.2.1

May 25, 2012

Changes in this version

type Client

+ func (c *Client) AsyncCall(cmd string, args ...interface{}) Future

+ func (c *Client) AsyncMultiCall(mc func(*MultiCall)) Future

+ func (c *Client) Call(cmd string, args ...interface{}) *Reply

+ func (c *Client) MultiCall(f func(*MultiCall)) *Reply

+ type Cmd string

+ const CmdAppend

+ const CmdAsking

+ const CmdAuth

+ const CmdBgrewriteaof

+ const CmdBgsave

+ const CmdBlpop

+ const CmdBrpop

+ const CmdBrpoplpush

+ const CmdClient

+ const CmdCluster

+ const CmdConfig

+ const CmdDbsize

+ const CmdDebug

+ const CmdDecr

+ const CmdDecrby

+ const CmdDel

+ const CmdDiscard

+ const CmdDump

+ const CmdEcho

+ const CmdEval

+ const CmdExec

+ const CmdExists

+ const CmdExpire

+ const CmdExpireat

+ const CmdFlushall

+ const CmdFlushdb

+ const CmdGet

+ const CmdGetbit

+ const CmdGetrange

+ const CmdGetset

+ const CmdHdel

+ const CmdHexists

+ const CmdHget

+ const CmdHgetall

+ const CmdHincrby

+ const CmdHincrbyfloat

+ const CmdHkeys

+ const CmdHlen

+ const CmdHmget

+ const CmdHmset

+ const CmdHset

+ const CmdHsetnx

+ const CmdHvals

+ const CmdIncr

+ const CmdIncrby

+ const CmdIncrbyfloat

+ const CmdInfo

+ const CmdKeys

+ const CmdLastsave

+ const CmdLindex

+ const CmdLinsert

+ const CmdLlen

+ const CmdLpop

+ const CmdLpush

+ const CmdLpushx

+ const CmdLrange

+ const CmdLrem

+ const CmdLset

+ const CmdLtrim

+ const CmdMget

+ const CmdMigrate

+ const CmdMonitor

+ const CmdMove

+ const CmdMset

+ const CmdMsetnx

+ const CmdMulti

+ const CmdObject

+ const CmdPersist

+ const CmdPexpire

+ const CmdPexpireat

+ const CmdPing

+ const CmdPsetex

+ const CmdPsubscribe

+ const CmdPttl

+ const CmdPublish

+ const CmdPunsubscribe

+ const CmdRandomkey

+ const CmdRename

+ const CmdRenamenx

+ const CmdRestore

+ const CmdRpop

+ const CmdRpoplpush

+ const CmdRpush

+ const CmdRpushx

+ const CmdSadd

+ const CmdSave

+ const CmdScard

+ const CmdScript

+ const CmdSdiff

+ const CmdSdiffstore

+ const CmdSelect

+ const CmdSet

+ const CmdSetbit

+ const CmdSetex

+ const CmdSetnx

+ const CmdSetrange

+ const CmdShutdown

+ const CmdSinter

+ const CmdSinterstore

+ const CmdSismember

+ const CmdSlaveof

+ const CmdSmembers

+ const CmdSmove

+ const CmdSort

+ const CmdSpop

+ const CmdSrandmember

+ const CmdSrem

+ const CmdStrlen

+ const CmdSubscribe

+ const CmdSunion

+ const CmdSunionstore

+ const CmdSync

+ const CmdTime

+ const CmdTtl

+ const CmdType

+ const CmdUnsubscribe

+ const CmdUnwatch

+ const CmdWatch

+ const CmdZadd

+ const CmdZcard

+ const CmdZcount

+ const CmdZincrby

+ const CmdZinterstore

+ const CmdZrange

+ const CmdZrangebyscore

+ const CmdZrank

+ const CmdZrem

+ const CmdZremrangebyrank

+ const CmdZremrangebyscore

+ const CmdZrevrange

+ const CmdZrevrangebyscore

+ const CmdZrevrank

+ const CmdZscore

+ const CmdZunionstore

type Error

+ Cmd Cmd

+ type MultiCall struct

+ func (mc *MultiCall) Append(args ...interface{})

+ func (mc *MultiCall) Asking(args ...interface{})

+ func (mc *MultiCall) Auth(args ...interface{})

+ func (mc *MultiCall) Bgrewriteaof(args ...interface{})

+ func (mc *MultiCall) Bgsave(args ...interface{})

+ func (mc *MultiCall) Blpop(args ...interface{})

+ func (mc *MultiCall) Brpop(args ...interface{})

+ func (mc *MultiCall) Brpoplpush(args ...interface{})

+ func (mc *MultiCall) Call(cmd string, args ...interface{})

+ func (mc *MultiCall) Client(args ...interface{})

+ func (mc *MultiCall) Cluster(args ...interface{})

+ func (mc *MultiCall) Config(args ...interface{})

+ func (mc *MultiCall) Dbsize(args ...interface{})

+ func (mc *MultiCall) Debug(args ...interface{})

+ func (mc *MultiCall) Decr(args ...interface{})

+ func (mc *MultiCall) Decrby(args ...interface{})

+ func (mc *MultiCall) Del(args ...interface{})

+ func (mc *MultiCall) Discard(args ...interface{})

+ func (mc *MultiCall) Dump(args ...interface{})

+ func (mc *MultiCall) Echo(args ...interface{})

+ func (mc *MultiCall) Eval(args ...interface{})

+ func (mc *MultiCall) Exec(args ...interface{})

+ func (mc *MultiCall) Exists(args ...interface{})

+ func (mc *MultiCall) Expire(args ...interface{})

+ func (mc *MultiCall) Expireat(args ...interface{})

+ func (mc *MultiCall) Flush() (r *Reply)

+ func (mc *MultiCall) Flushall(args ...interface{})

+ func (mc *MultiCall) Flushdb(args ...interface{})

+ func (mc *MultiCall) Get(args ...interface{})

+ func (mc *MultiCall) Getbit(args ...interface{})

+ func (mc *MultiCall) Getrange(args ...interface{})

+ func (mc *MultiCall) Getset(args ...interface{})

+ func (mc *MultiCall) Hdel(args ...interface{})

+ func (mc *MultiCall) Hexists(args ...interface{})

+ func (mc *MultiCall) Hget(args ...interface{})

+ func (mc *MultiCall) Hgetall(args ...interface{})

+ func (mc *MultiCall) Hincrby(args ...interface{})

+ func (mc *MultiCall) Hincrbyfloat(args ...interface{})

+ func (mc *MultiCall) Hkeys(args ...interface{})

+ func (mc *MultiCall) Hlen(args ...interface{})

+ func (mc *MultiCall) Hmget(args ...interface{})

+ func (mc *MultiCall) Hmset(args ...interface{})

+ func (mc *MultiCall) Hset(args ...interface{})

+ func (mc *MultiCall) Hsetnx(args ...interface{})

+ func (mc *MultiCall) Hvals(args ...interface{})

+ func (mc *MultiCall) Incr(args ...interface{})

+ func (mc *MultiCall) Incrby(args ...interface{})

+ func (mc *MultiCall) Incrbyfloat(args ...interface{})

+ func (mc *MultiCall) Info(args ...interface{})

+ func (mc *MultiCall) Keys(args ...interface{})

+ func (mc *MultiCall) Lastsave(args ...interface{})

+ func (mc *MultiCall) Lindex(args ...interface{})

+ func (mc *MultiCall) Linsert(args ...interface{})

+ func (mc *MultiCall) Llen(args ...interface{})

+ func (mc *MultiCall) Lpop(args ...interface{})

+ func (mc *MultiCall) Lpush(args ...interface{})

+ func (mc *MultiCall) Lpushx(args ...interface{})

+ func (mc *MultiCall) Lrange(args ...interface{})

+ func (mc *MultiCall) Lrem(args ...interface{})

+ func (mc *MultiCall) Lset(args ...interface{})

+ func (mc *MultiCall) Ltrim(args ...interface{})

+ func (mc *MultiCall) Mget(args ...interface{})

+ func (mc *MultiCall) Migrate(args ...interface{})

+ func (mc *MultiCall) Monitor(args ...interface{})

+ func (mc *MultiCall) Move(args ...interface{})

+ func (mc *MultiCall) Mset(args ...interface{})

+ func (mc *MultiCall) Msetnx(args ...interface{})

+ func (mc *MultiCall) Multi(args ...interface{})

+ func (mc *MultiCall) Object(args ...interface{})

+ func (mc *MultiCall) Persist(args ...interface{})

+ func (mc *MultiCall) Pexpire(args ...interface{})

+ func (mc *MultiCall) Pexpireat(args ...interface{})

+ func (mc *MultiCall) Ping(args ...interface{})

+ func (mc *MultiCall) Psetex(args ...interface{})

+ func (mc *MultiCall) Psubscribe(args ...interface{})

+ func (mc *MultiCall) Pttl(args ...interface{})

+ func (mc *MultiCall) Publish(args ...interface{})

+ func (mc *MultiCall) Punsubscribe(args ...interface{})

+ func (mc *MultiCall) Randomkey(args ...interface{})

+ func (mc *MultiCall) Rename(args ...interface{})

+ func (mc *MultiCall) Renamenx(args ...interface{})

+ func (mc *MultiCall) Restore(args ...interface{})

+ func (mc *MultiCall) Rpop(args ...interface{})

+ func (mc *MultiCall) Rpoplpush(args ...interface{})

+ func (mc *MultiCall) Rpush(args ...interface{})

+ func (mc *MultiCall) Rpushx(args ...interface{})

+ func (mc *MultiCall) Sadd(args ...interface{})

+ func (mc *MultiCall) Save(args ...interface{})

+ func (mc *MultiCall) Scard(args ...interface{})

+ func (mc *MultiCall) Script(args ...interface{})

+ func (mc *MultiCall) Sdiff(args ...interface{})

+ func (mc *MultiCall) Sdiffstore(args ...interface{})

+ func (mc *MultiCall) Select(args ...interface{})

+ func (mc *MultiCall) Set(args ...interface{})

+ func (mc *MultiCall) Setbit(args ...interface{})

+ func (mc *MultiCall) Setex(args ...interface{})

+ func (mc *MultiCall) Setnx(args ...interface{})

+ func (mc *MultiCall) Setrange(args ...interface{})

+ func (mc *MultiCall) Shutdown(args ...interface{})

+ func (mc *MultiCall) Sinter(args ...interface{})

+ func (mc *MultiCall) Sinterstore(args ...interface{})

+ func (mc *MultiCall) Sismember(args ...interface{})

+ func (mc *MultiCall) Slaveof(args ...interface{})

+ func (mc *MultiCall) Smembers(args ...interface{})

+ func (mc *MultiCall) Smove(args ...interface{})

+ func (mc *MultiCall) Sort(args ...interface{})

+ func (mc *MultiCall) Spop(args ...interface{})

+ func (mc *MultiCall) Srandmember(args ...interface{})

+ func (mc *MultiCall) Srem(args ...interface{})

+ func (mc *MultiCall) Strlen(args ...interface{})

+ func (mc *MultiCall) Subscribe(args ...interface{})

+ func (mc *MultiCall) Sunion(args ...interface{})

+ func (mc *MultiCall) Sunionstore(args ...interface{})

+ func (mc *MultiCall) Sync(args ...interface{})

+ func (mc *MultiCall) Time(args ...interface{})

+ func (mc *MultiCall) Ttl(args ...interface{})

+ func (mc *MultiCall) Type(args ...interface{})

+ func (mc *MultiCall) Unsubscribe(args ...interface{})

+ func (mc *MultiCall) Unwatch(args ...interface{})

+ func (mc *MultiCall) Watch(args ...interface{})

+ func (mc *MultiCall) Zadd(args ...interface{})

+ func (mc *MultiCall) Zcard(args ...interface{})

+ func (mc *MultiCall) Zcount(args ...interface{})

+ func (mc *MultiCall) Zincrby(args ...interface{})

+ func (mc *MultiCall) Zinterstore(args ...interface{})

+ func (mc *MultiCall) Zrange(args ...interface{})

+ func (mc *MultiCall) Zrangebyscore(args ...interface{})

+ func (mc *MultiCall) Zrank(args ...interface{})

+ func (mc *MultiCall) Zrem(args ...interface{})

+ func (mc *MultiCall) Zremrangebyrank(args ...interface{})

+ func (mc *MultiCall) Zremrangebyscore(args ...interface{})

+ func (mc *MultiCall) Zrevrange(args ...interface{})

+ func (mc *MultiCall) Zrevrangebyscore(args ...interface{})

+ func (mc *MultiCall) Zrevrank(args ...interface{})

+ func (mc *MultiCall) Zscore(args ...interface{})

+ func (mc *MultiCall) Zunionstore(args ...interface{})

type Reply

+ Cmd Cmd

v0.2.0

May 19, 2012

Changes in this version

type Client

+ func (c *Client) Append(args ...interface{}) *Reply

+ func (c *Client) Asking(args ...interface{}) *Reply

+ func (c *Client) AsyncAppend(args ...interface{}) Future

+ func (c *Client) AsyncAsking(args ...interface{}) Future

+ func (c *Client) AsyncAuth(args ...interface{}) Future

+ func (c *Client) AsyncBgrewriteaof(args ...interface{}) Future

+ func (c *Client) AsyncBgsave(args ...interface{}) Future

+ func (c *Client) AsyncBlpop(args ...interface{}) Future

+ func (c *Client) AsyncBrpop(args ...interface{}) Future

+ func (c *Client) AsyncBrpoplpush(args ...interface{}) Future

+ func (c *Client) AsyncClient(args ...interface{}) Future

+ func (c *Client) AsyncCluster(args ...interface{}) Future

+ func (c *Client) AsyncConfig(args ...interface{}) Future

+ func (c *Client) AsyncDbsize(args ...interface{}) Future

+ func (c *Client) AsyncDebug(args ...interface{}) Future

+ func (c *Client) AsyncDecr(args ...interface{}) Future

+ func (c *Client) AsyncDecrby(args ...interface{}) Future

+ func (c *Client) AsyncDel(args ...interface{}) Future

+ func (c *Client) AsyncDiscard(args ...interface{}) Future

+ func (c *Client) AsyncDump(args ...interface{}) Future

+ func (c *Client) AsyncEcho(args ...interface{}) Future

+ func (c *Client) AsyncEval(args ...interface{}) Future

+ func (c *Client) AsyncExec(args ...interface{}) Future

+ func (c *Client) AsyncExists(args ...interface{}) Future

+ func (c *Client) AsyncExpire(args ...interface{}) Future

+ func (c *Client) AsyncExpireat(args ...interface{}) Future

+ func (c *Client) AsyncFlushall(args ...interface{}) Future

+ func (c *Client) AsyncFlushdb(args ...interface{}) Future

+ func (c *Client) AsyncGet(args ...interface{}) Future

+ func (c *Client) AsyncGetbit(args ...interface{}) Future

+ func (c *Client) AsyncGetrange(args ...interface{}) Future

+ func (c *Client) AsyncGetset(args ...interface{}) Future

+ func (c *Client) AsyncHdel(args ...interface{}) Future

+ func (c *Client) AsyncHexists(args ...interface{}) Future

+ func (c *Client) AsyncHget(args ...interface{}) Future

+ func (c *Client) AsyncHgetall(args ...interface{}) Future

+ func (c *Client) AsyncHincrby(args ...interface{}) Future

+ func (c *Client) AsyncHincrbyfloat(args ...interface{}) Future

+ func (c *Client) AsyncHkeys(args ...interface{}) Future

+ func (c *Client) AsyncHlen(args ...interface{}) Future

+ func (c *Client) AsyncHmget(args ...interface{}) Future

+ func (c *Client) AsyncHmset(args ...interface{}) Future

+ func (c *Client) AsyncHset(args ...interface{}) Future

+ func (c *Client) AsyncHsetnx(args ...interface{}) Future

+ func (c *Client) AsyncHvals(args ...interface{}) Future

+ func (c *Client) AsyncIncr(args ...interface{}) Future

+ func (c *Client) AsyncIncrby(args ...interface{}) Future

+ func (c *Client) AsyncIncrbyfloat(args ...interface{}) Future

+ func (c *Client) AsyncInfo(args ...interface{}) Future

+ func (c *Client) AsyncKeys(args ...interface{}) Future

+ func (c *Client) AsyncLastsave(args ...interface{}) Future

+ func (c *Client) AsyncLindex(args ...interface{}) Future

+ func (c *Client) AsyncLinsert(args ...interface{}) Future

+ func (c *Client) AsyncLlen(args ...interface{}) Future

+ func (c *Client) AsyncLpop(args ...interface{}) Future

+ func (c *Client) AsyncLpush(args ...interface{}) Future

+ func (c *Client) AsyncLpushx(args ...interface{}) Future

+ func (c *Client) AsyncLrange(args ...interface{}) Future

+ func (c *Client) AsyncLrem(args ...interface{}) Future

+ func (c *Client) AsyncLset(args ...interface{}) Future

+ func (c *Client) AsyncLtrim(args ...interface{}) Future

+ func (c *Client) AsyncMget(args ...interface{}) Future

+ func (c *Client) AsyncMigrate(args ...interface{}) Future

+ func (c *Client) AsyncMonitor(args ...interface{}) Future

+ func (c *Client) AsyncMove(args ...interface{}) Future

+ func (c *Client) AsyncMset(args ...interface{}) Future

+ func (c *Client) AsyncMsetnx(args ...interface{}) Future

+ func (c *Client) AsyncMulti(args ...interface{}) Future

+ func (c *Client) AsyncObject(args ...interface{}) Future

+ func (c *Client) AsyncPersist(args ...interface{}) Future

+ func (c *Client) AsyncPexpire(args ...interface{}) Future

+ func (c *Client) AsyncPexpireat(args ...interface{}) Future

+ func (c *Client) AsyncPing(args ...interface{}) Future

+ func (c *Client) AsyncPsetex(args ...interface{}) Future

+ func (c *Client) AsyncPsubscribe(args ...interface{}) Future

+ func (c *Client) AsyncPttl(args ...interface{}) Future

+ func (c *Client) AsyncPublish(args ...interface{}) Future

+ func (c *Client) AsyncPunsubscribe(args ...interface{}) Future

+ func (c *Client) AsyncRandomkey(args ...interface{}) Future

+ func (c *Client) AsyncRename(args ...interface{}) Future

+ func (c *Client) AsyncRenamenx(args ...interface{}) Future

+ func (c *Client) AsyncRestore(args ...interface{}) Future

+ func (c *Client) AsyncRpop(args ...interface{}) Future

+ func (c *Client) AsyncRpoplpush(args ...interface{}) Future

+ func (c *Client) AsyncRpush(args ...interface{}) Future

+ func (c *Client) AsyncRpushx(args ...interface{}) Future

+ func (c *Client) AsyncSadd(args ...interface{}) Future

+ func (c *Client) AsyncSave(args ...interface{}) Future

+ func (c *Client) AsyncScard(args ...interface{}) Future

+ func (c *Client) AsyncScript(args ...interface{}) Future

+ func (c *Client) AsyncSdiff(args ...interface{}) Future

+ func (c *Client) AsyncSdiffstore(args ...interface{}) Future

+ func (c *Client) AsyncSelect(args ...interface{}) Future

+ func (c *Client) AsyncSet(args ...interface{}) Future

+ func (c *Client) AsyncSetbit(args ...interface{}) Future

+ func (c *Client) AsyncSetex(args ...interface{}) Future

+ func (c *Client) AsyncSetnx(args ...interface{}) Future

+ func (c *Client) AsyncSetrange(args ...interface{}) Future

+ func (c *Client) AsyncShutdown(args ...interface{}) Future

+ func (c *Client) AsyncSinter(args ...interface{}) Future

+ func (c *Client) AsyncSinterstore(args ...interface{}) Future

+ func (c *Client) AsyncSismember(args ...interface{}) Future

+ func (c *Client) AsyncSlaveof(args ...interface{}) Future

+ func (c *Client) AsyncSmembers(args ...interface{}) Future

+ func (c *Client) AsyncSmove(args ...interface{}) Future

+ func (c *Client) AsyncSort(args ...interface{}) Future

+ func (c *Client) AsyncSpop(args ...interface{}) Future

+ func (c *Client) AsyncSrandmember(args ...interface{}) Future

+ func (c *Client) AsyncSrem(args ...interface{}) Future

+ func (c *Client) AsyncStrlen(args ...interface{}) Future

+ func (c *Client) AsyncSubscribe(args ...interface{}) Future

+ func (c *Client) AsyncSunion(args ...interface{}) Future

+ func (c *Client) AsyncSunionstore(args ...interface{}) Future

+ func (c *Client) AsyncSync(args ...interface{}) Future

+ func (c *Client) AsyncTime(args ...interface{}) Future

+ func (c *Client) AsyncTtl(args ...interface{}) Future

+ func (c *Client) AsyncType(args ...interface{}) Future

+ func (c *Client) AsyncUnsubscribe(args ...interface{}) Future

+ func (c *Client) AsyncUnwatch(args ...interface{}) Future

+ func (c *Client) AsyncWatch(args ...interface{}) Future

+ func (c *Client) AsyncZadd(args ...interface{}) Future

+ func (c *Client) AsyncZcard(args ...interface{}) Future

+ func (c *Client) AsyncZcount(args ...interface{}) Future

+ func (c *Client) AsyncZincrby(args ...interface{}) Future

+ func (c *Client) AsyncZinterstore(args ...interface{}) Future

+ func (c *Client) AsyncZrange(args ...interface{}) Future

+ func (c *Client) AsyncZrangebyscore(args ...interface{}) Future

+ func (c *Client) AsyncZrank(args ...interface{}) Future

+ func (c *Client) AsyncZrem(args ...interface{}) Future

+ func (c *Client) AsyncZremrangebyrank(args ...interface{}) Future

+ func (c *Client) AsyncZremrangebyscore(args ...interface{}) Future

+ func (c *Client) AsyncZrevrange(args ...interface{}) Future

+ func (c *Client) AsyncZrevrangebyscore(args ...interface{}) Future

+ func (c *Client) AsyncZrevrank(args ...interface{}) Future

+ func (c *Client) AsyncZscore(args ...interface{}) Future

+ func (c *Client) AsyncZunionstore(args ...interface{}) Future

+ func (c *Client) Auth(args ...interface{}) *Reply

+ func (c *Client) Bgrewriteaof(args ...interface{}) *Reply

+ func (c *Client) Bgsave(args ...interface{}) *Reply

+ func (c *Client) Blpop(args ...interface{}) *Reply

+ func (c *Client) Brpop(args ...interface{}) *Reply

+ func (c *Client) Brpoplpush(args ...interface{}) *Reply

+ func (c *Client) Client(args ...interface{}) *Reply

+ func (c *Client) Cluster(args ...interface{}) *Reply

+ func (c *Client) Config(args ...interface{}) *Reply

+ func (c *Client) Dbsize(args ...interface{}) *Reply

+ func (c *Client) Debug(args ...interface{}) *Reply

+ func (c *Client) Decr(args ...interface{}) *Reply

+ func (c *Client) Decrby(args ...interface{}) *Reply

+ func (c *Client) Del(args ...interface{}) *Reply

+ func (c *Client) Discard(args ...interface{}) *Reply

+ func (c *Client) Dump(args ...interface{}) *Reply

+ func (c *Client) Echo(args ...interface{}) *Reply

+ func (c *Client) Eval(args ...interface{}) *Reply

+ func (c *Client) Exec(args ...interface{}) *Reply

+ func (c *Client) Exists(args ...interface{}) *Reply

+ func (c *Client) Expire(args ...interface{}) *Reply

+ func (c *Client) Expireat(args ...interface{}) *Reply

+ func (c *Client) Flushall(args ...interface{}) *Reply

+ func (c *Client) Flushdb(args ...interface{}) *Reply

+ func (c *Client) Get(args ...interface{}) *Reply

+ func (c *Client) Getbit(args ...interface{}) *Reply

+ func (c *Client) Getrange(args ...interface{}) *Reply

+ func (c *Client) Getset(args ...interface{}) *Reply

+ func (c *Client) Hdel(args ...interface{}) *Reply

+ func (c *Client) Hexists(args ...interface{}) *Reply

+ func (c *Client) Hget(args ...interface{}) *Reply

+ func (c *Client) Hgetall(args ...interface{}) *Reply

+ func (c *Client) Hincrby(args ...interface{}) *Reply

+ func (c *Client) Hincrbyfloat(args ...interface{}) *Reply

+ func (c *Client) Hkeys(args ...interface{}) *Reply

+ func (c *Client) Hlen(args ...interface{}) *Reply

+ func (c *Client) Hmget(args ...interface{}) *Reply

+ func (c *Client) Hmset(args ...interface{}) *Reply

+ func (c *Client) Hset(args ...interface{}) *Reply

+ func (c *Client) Hsetnx(args ...interface{}) *Reply

+ func (c *Client) Hvals(args ...interface{}) *Reply

+ func (c *Client) Incr(args ...interface{}) *Reply

+ func (c *Client) Incrby(args ...interface{}) *Reply

+ func (c *Client) Incrbyfloat(args ...interface{}) *Reply

+ func (c *Client) Info(args ...interface{}) *Reply

+ func (c *Client) Keys(args ...interface{}) *Reply

+ func (c *Client) Lastsave(args ...interface{}) *Reply

+ func (c *Client) Lindex(args ...interface{}) *Reply

+ func (c *Client) Linsert(args ...interface{}) *Reply

+ func (c *Client) Llen(args ...interface{}) *Reply

+ func (c *Client) Lpop(args ...interface{}) *Reply

+ func (c *Client) Lpush(args ...interface{}) *Reply

+ func (c *Client) Lpushx(args ...interface{}) *Reply

+ func (c *Client) Lrange(args ...interface{}) *Reply

+ func (c *Client) Lrem(args ...interface{}) *Reply

+ func (c *Client) Lset(args ...interface{}) *Reply

+ func (c *Client) Ltrim(args ...interface{}) *Reply

+ func (c *Client) Mget(args ...interface{}) *Reply

+ func (c *Client) Migrate(args ...interface{}) *Reply

+ func (c *Client) Monitor(args ...interface{}) *Reply

+ func (c *Client) Move(args ...interface{}) *Reply

+ func (c *Client) Mset(args ...interface{}) *Reply

+ func (c *Client) Msetnx(args ...interface{}) *Reply

+ func (c *Client) Multi(args ...interface{}) *Reply

+ func (c *Client) Object(args ...interface{}) *Reply

+ func (c *Client) Persist(args ...interface{}) *Reply

+ func (c *Client) Pexpire(args ...interface{}) *Reply

+ func (c *Client) Pexpireat(args ...interface{}) *Reply

+ func (c *Client) Ping(args ...interface{}) *Reply

+ func (c *Client) Psetex(args ...interface{}) *Reply

+ func (c *Client) Psubscribe(args ...interface{}) *Reply

+ func (c *Client) Pttl(args ...interface{}) *Reply

+ func (c *Client) Publish(args ...interface{}) *Reply

+ func (c *Client) Punsubscribe(args ...interface{}) *Reply

+ func (c *Client) Randomkey(args ...interface{}) *Reply

+ func (c *Client) Rename(args ...interface{}) *Reply

+ func (c *Client) Renamenx(args ...interface{}) *Reply

+ func (c *Client) Restore(args ...interface{}) *Reply

+ func (c *Client) Rpop(args ...interface{}) *Reply

+ func (c *Client) Rpoplpush(args ...interface{}) *Reply

+ func (c *Client) Rpush(args ...interface{}) *Reply

+ func (c *Client) Rpushx(args ...interface{}) *Reply

+ func (c *Client) Sadd(args ...interface{}) *Reply

+ func (c *Client) Save(args ...interface{}) *Reply

+ func (c *Client) Scard(args ...interface{}) *Reply

+ func (c *Client) Script(args ...interface{}) *Reply

+ func (c *Client) Sdiff(args ...interface{}) *Reply

+ func (c *Client) Sdiffstore(args ...interface{}) *Reply

+ func (c *Client) Set(args ...interface{}) *Reply

+ func (c *Client) Setbit(args ...interface{}) *Reply

+ func (c *Client) Setex(args ...interface{}) *Reply

+ func (c *Client) Setnx(args ...interface{}) *Reply

+ func (c *Client) Setrange(args ...interface{}) *Reply

+ func (c *Client) Shutdown(args ...interface{}) *Reply

+ func (c *Client) Sinter(args ...interface{}) *Reply

+ func (c *Client) Sinterstore(args ...interface{}) *Reply

+ func (c *Client) Sismember(args ...interface{}) *Reply

+ func (c *Client) Slaveof(args ...interface{}) *Reply

+ func (c *Client) Smembers(args ...interface{}) *Reply

+ func (c *Client) Smove(args ...interface{}) *Reply

+ func (c *Client) Sort(args ...interface{}) *Reply

+ func (c *Client) Spop(args ...interface{}) *Reply

+ func (c *Client) Srandmember(args ...interface{}) *Reply

+ func (c *Client) Srem(args ...interface{}) *Reply

+ func (c *Client) Strlen(args ...interface{}) *Reply

+ func (c *Client) Subscribe(args ...interface{}) *Reply

+ func (c *Client) Sunion(args ...interface{}) *Reply

+ func (c *Client) Sunionstore(args ...interface{}) *Reply

+ func (c *Client) Sync(args ...interface{}) *Reply

+ func (c *Client) Time(args ...interface{}) *Reply

+ func (c *Client) Ttl(args ...interface{}) *Reply

+ func (c *Client) Type(args ...interface{}) *Reply

+ func (c *Client) Unsubscribe(args ...interface{}) *Reply

+ func (c *Client) Unwatch(args ...interface{}) *Reply

+ func (c *Client) Watch(args ...interface{}) *Reply

+ func (c *Client) Zadd(args ...interface{}) *Reply

+ func (c *Client) Zcard(args ...interface{}) *Reply

+ func (c *Client) Zcount(args ...interface{}) *Reply

+ func (c *Client) Zincrby(args ...interface{}) *Reply

+ func (c *Client) Zinterstore(args ...interface{}) *Reply

+ func (c *Client) Zrange(args ...interface{}) *Reply

+ func (c *Client) Zrangebyscore(args ...interface{}) *Reply

+ func (c *Client) Zrank(args ...interface{}) *Reply

+ func (c *Client) Zrem(args ...interface{}) *Reply

+ func (c *Client) Zremrangebyrank(args ...interface{}) *Reply

+ func (c *Client) Zremrangebyscore(args ...interface{}) *Reply

+ func (c *Client) Zrevrange(args ...interface{}) *Reply

+ func (c *Client) Zrevrangebyscore(args ...interface{}) *Reply

+ func (c *Client) Zrevrank(args ...interface{}) *Reply

+ func (c *Client) Zscore(args ...interface{}) *Reply

+ func (c *Client) Zunionstore(args ...interface{}) *Reply

type MessageType

+ const MessagePmessage

+ const MessagePsubscribe

+ const MessagePunsubscribe

type MultiCommand

+ func (mc *MultiCommand) Append(args ...interface{})

+ func (mc *MultiCommand) Asking(args ...interface{})

+ func (mc *MultiCommand) Auth(args ...interface{})

+ func (mc *MultiCommand) Bgrewriteaof(args ...interface{})

+ func (mc *MultiCommand) Bgsave(args ...interface{})

+ func (mc *MultiCommand) Blpop(args ...interface{})

+ func (mc *MultiCommand) Brpop(args ...interface{})

+ func (mc *MultiCommand) Brpoplpush(args ...interface{})

+ func (mc *MultiCommand) Client(args ...interface{})

+ func (mc *MultiCommand) Cluster(args ...interface{})

+ func (mc *MultiCommand) Config(args ...interface{})

+ func (mc *MultiCommand) Dbsize(args ...interface{})

+ func (mc *MultiCommand) Debug(args ...interface{})

+ func (mc *MultiCommand) Decr(args ...interface{})

+ func (mc *MultiCommand) Decrby(args ...interface{})

+ func (mc *MultiCommand) Del(args ...interface{})

+ func (mc *MultiCommand) Discard(args ...interface{})

+ func (mc *MultiCommand) Dump(args ...interface{})

+ func (mc *MultiCommand) Echo(args ...interface{})

+ func (mc *MultiCommand) Eval(args ...interface{})

+ func (mc *MultiCommand) Exec(args ...interface{})

+ func (mc *MultiCommand) Exists(args ...interface{})

+ func (mc *MultiCommand) Expire(args ...interface{})

+ func (mc *MultiCommand) Expireat(args ...interface{})

+ func (mc *MultiCommand) Flushall(args ...interface{})

+ func (mc *MultiCommand) Flushdb(args ...interface{})

+ func (mc *MultiCommand) Get(args ...interface{})

+ func (mc *MultiCommand) Getbit(args ...interface{})

+ func (mc *MultiCommand) Getrange(args ...interface{})

+ func (mc *MultiCommand) Getset(args ...interface{})

+ func (mc *MultiCommand) Hdel(args ...interface{})

+ func (mc *MultiCommand) Hexists(args ...interface{})

+ func (mc *MultiCommand) Hget(args ...interface{})

+ func (mc *MultiCommand) Hgetall(args ...interface{})

+ func (mc *MultiCommand) Hincrby(args ...interface{})

+ func (mc *MultiCommand) Hincrbyfloat(args ...interface{})

+ func (mc *MultiCommand) Hkeys(args ...interface{})

+ func (mc *MultiCommand) Hlen(args ...interface{})

+ func (mc *MultiCommand) Hmget(args ...interface{})

+ func (mc *MultiCommand) Hmset(args ...interface{})

+ func (mc *MultiCommand) Hset(args ...interface{})

+ func (mc *MultiCommand) Hsetnx(args ...interface{})

+ func (mc *MultiCommand) Hvals(args ...interface{})

+ func (mc *MultiCommand) Incr(args ...interface{})

+ func (mc *MultiCommand) Incrby(args ...interface{})

+ func (mc *MultiCommand) Incrbyfloat(args ...interface{})

+ func (mc *MultiCommand) Info(args ...interface{})

+ func (mc *MultiCommand) Keys(args ...interface{})

+ func (mc *MultiCommand) Lastsave(args ...interface{})

+ func (mc *MultiCommand) Lindex(args ...interface{})

+ func (mc *MultiCommand) Linsert(args ...interface{})

+ func (mc *MultiCommand) Llen(args ...interface{})

+ func (mc *MultiCommand) Lpop(args ...interface{})

+ func (mc *MultiCommand) Lpush(args ...interface{})

+ func (mc *MultiCommand) Lpushx(args ...interface{})

+ func (mc *MultiCommand) Lrange(args ...interface{})

+ func (mc *MultiCommand) Lrem(args ...interface{})

+ func (mc *MultiCommand) Lset(args ...interface{})

+ func (mc *MultiCommand) Ltrim(args ...interface{})

+ func (mc *MultiCommand) Mget(args ...interface{})

+ func (mc *MultiCommand) Migrate(args ...interface{})

+ func (mc *MultiCommand) Monitor(args ...interface{})

+ func (mc *MultiCommand) Move(args ...interface{})

+ func (mc *MultiCommand) Mset(args ...interface{})

+ func (mc *MultiCommand) Msetnx(args ...interface{})

+ func (mc *MultiCommand) Multi(args ...interface{})

+ func (mc *MultiCommand) Object(args ...interface{})

+ func (mc *MultiCommand) Persist(args ...interface{})

+ func (mc *MultiCommand) Pexpire(args ...interface{})

+ func (mc *MultiCommand) Pexpireat(args ...interface{})

+ func (mc *MultiCommand) Ping(args ...interface{})

+ func (mc *MultiCommand) Psetex(args ...interface{})

+ func (mc *MultiCommand) Psubscribe(args ...interface{})

+ func (mc *MultiCommand) Pttl(args ...interface{})

+ func (mc *MultiCommand) Publish(args ...interface{})

+ func (mc *MultiCommand) Punsubscribe(args ...interface{})

+ func (mc *MultiCommand) Randomkey(args ...interface{})

+ func (mc *MultiCommand) Rename(args ...interface{})

+ func (mc *MultiCommand) Renamenx(args ...interface{})

+ func (mc *MultiCommand) Restore(args ...interface{})

+ func (mc *MultiCommand) Rpop(args ...interface{})

+ func (mc *MultiCommand) Rpoplpush(args ...interface{})

+ func (mc *MultiCommand) Rpush(args ...interface{})

+ func (mc *MultiCommand) Rpushx(args ...interface{})

+ func (mc *MultiCommand) Sadd(args ...interface{})

+ func (mc *MultiCommand) Save(args ...interface{})

+ func (mc *MultiCommand) Scard(args ...interface{})

+ func (mc *MultiCommand) Script(args ...interface{})

+ func (mc *MultiCommand) Sdiff(args ...interface{})

+ func (mc *MultiCommand) Sdiffstore(args ...interface{})

+ func (mc *MultiCommand) Select(args ...interface{})

+ func (mc *MultiCommand) Set(args ...interface{})

+ func (mc *MultiCommand) Setbit(args ...interface{})

+ func (mc *MultiCommand) Setex(args ...interface{})

+ func (mc *MultiCommand) Setnx(args ...interface{})

+ func (mc *MultiCommand) Setrange(args ...interface{})

+ func (mc *MultiCommand) Shutdown(args ...interface{})

+ func (mc *MultiCommand) Sinter(args ...interface{})

+ func (mc *MultiCommand) Sinterstore(args ...interface{})

+ func (mc *MultiCommand) Sismember(args ...interface{})

+ func (mc *MultiCommand) Slaveof(args ...interface{})

+ func (mc *MultiCommand) Smembers(args ...interface{})

+ func (mc *MultiCommand) Smove(args ...interface{})

+ func (mc *MultiCommand) Sort(args ...interface{})

+ func (mc *MultiCommand) Spop(args ...interface{})

+ func (mc *MultiCommand) Srandmember(args ...interface{})

+ func (mc *MultiCommand) Srem(args ...interface{})

+ func (mc *MultiCommand) Strlen(args ...interface{})

+ func (mc *MultiCommand) Subscribe(args ...interface{})

+ func (mc *MultiCommand) Sunion(args ...interface{})

+ func (mc *MultiCommand) Sunionstore(args ...interface{})

+ func (mc *MultiCommand) Sync(args ...interface{})

+ func (mc *MultiCommand) Time(args ...interface{})

+ func (mc *MultiCommand) Ttl(args ...interface{})

+ func (mc *MultiCommand) Type(args ...interface{})

+ func (mc *MultiCommand) Unsubscribe(args ...interface{})

+ func (mc *MultiCommand) Unwatch(args ...interface{})

+ func (mc *MultiCommand) Watch(args ...interface{})

+ func (mc *MultiCommand) Zadd(args ...interface{})

+ func (mc *MultiCommand) Zcard(args ...interface{})

+ func (mc *MultiCommand) Zcount(args ...interface{})

+ func (mc *MultiCommand) Zincrby(args ...interface{})

+ func (mc *MultiCommand) Zinterstore(args ...interface{})

+ func (mc *MultiCommand) Zrange(args ...interface{})

+ func (mc *MultiCommand) Zrangebyscore(args ...interface{})

+ func (mc *MultiCommand) Zrank(args ...interface{})

+ func (mc *MultiCommand) Zrem(args ...interface{})

+ func (mc *MultiCommand) Zremrangebyrank(args ...interface{})

+ func (mc *MultiCommand) Zremrangebyscore(args ...interface{})

+ func (mc *MultiCommand) Zrevrange(args ...interface{})

+ func (mc *MultiCommand) Zrevrangebyscore(args ...interface{})

+ func (mc *MultiCommand) Zrevrank(args ...interface{})

+ func (mc *MultiCommand) Zscore(args ...interface{})

+ func (mc *MultiCommand) Zunionstore(args ...interface{})

type Subscription

+ func (s *Subscription) Psubscribe(patterns ...string) *Error

+ func (s *Subscription) Punsubscribe(patterns ...string) *Error

v0.1.5

May 15, 2012

Changes in this version

+ type Command string

+ const Append

+ const Asking

+ const Auth

+ const Bgrewriteaof

+ const Bgsave

+ const Blpop

+ const Brpop

+ const Brpoplpush

+ const ClientCmd

+ const Cluster

+ const Config

+ const Dbsize

+ const Debug

+ const Decr

+ const Decrby

+ const Del

+ const Discard

+ const Dump

+ const Echo

+ const Eval

+ const Exec

+ const Exists

+ const Expire

+ const Expireat

+ const Flushall

+ const Flushdb

+ const Get

+ const Getbit

+ const Getrange

+ const Getset

+ const Hdel

+ const Hexists

+ const Hget

+ const Hgetall

+ const Hincrby

+ const Hincrbyfloat

+ const Hkeys

+ const Hlen

+ const Hmget

+ const Hmset

+ const Hset

+ const Hsetnx

+ const Hvals

+ const Incr

+ const Incrby

+ const Incrbyfloat

+ const Info

+ const Keys

+ const Lastsave

+ const Lindex

+ const Linsert

+ const Llen

+ const Lpop

+ const Lpush

+ const Lpushx

+ const Lrange

+ const Lrem

+ const Lset

+ const Ltrim

+ const Mget

+ const Migrate

+ const Monitor

+ const Move

+ const Mset

+ const Msetnx

+ const Multi

+ const Object

+ const Persist

+ const Pexpire

+ const Pexpireat

+ const Ping

+ const Psetex

+ const Psubscribe

+ const Pttl

+ const Publish

+ const Punsubscribe

+ const Randomkey

+ const Rename

+ const Renamenx

+ const Restore

+ const Rpop

+ const Rpoplpush

+ const Rpush

+ const Rpushx

+ const Sadd

+ const Save

+ const Scard

+ const Script

+ const Sdiff

+ const Sdiffstore

+ const Select

+ const Set

+ const Setbit

+ const Setex

+ const Setnx

+ const Setrange

+ const Shutdown

+ const Sinter

+ const Sinterstore

+ const Sismember

+ const Slaveof

+ const Smembers

+ const Smove

+ const Sort

+ const Spop

+ const Srandmember

+ const Srem

+ const Strlen

+ const Subscribe

+ const Sunion

+ const Sunionstore

+ const Sync

+ const Time

+ const Ttl

+ const Type

+ const Unsubscribe

+ const Unwatch

+ const Watch

+ const Zadd

+ const Zcard

+ const Zcount

+ const Zincrby

+ const Zinterstore

+ const Zrange

+ const Zrangebyscore

+ const Zrank

+ const Zrem

+ const Zremrangebyrank

+ const Zremrangebyscore

+ const Zrevrange

+ const Zrevrangebyscore

+ const Zrevrank

+ const Zscore

+ const Zunionstore

v0.1.1

Mar 1, 2012

Changes in this version

+ type Client struct

+ func NewClient(conf Configuration) *Client

+ func (c *Client) AsyncCommand(cmd string, args ...interface{}) Future

+ func (c *Client) AsyncMultiCommand(f func(*MultiCommand)) Future

+ func (c *Client) AsyncTransaction(f func(*MultiCommand)) Future

+ func (c *Client) Close()

+ func (c *Client) Command(cmd string, args ...interface{}) *Reply

+ func (c *Client) MultiCommand(f func(*MultiCommand)) *Reply

+ func (c *Client) Select(database int)

+ func (c *Client) Subscription(msgHdlr func(msg *Message)) (*Subscription, *Error)

+ func (c *Client) Transaction(f func(*MultiCommand)) *Reply

+ type Configuration struct

+ Address string

+ Auth string

+ Database int

+ NoLoadingRetry bool

+ Path string

+ PoolSize int

+ Timeout int

+ type Error struct

+ func (e *Error) Error() string

+ func (e *Error) Test(flags ...ErrorFlag) bool

+ type ErrorFlag uint8

+ const ErrorAuth

+ const ErrorConnection

+ const ErrorInvalidReply

+ const ErrorLoading

+ const ErrorParse

+ const ErrorRedis

+ const ErrorTimeout

+ type Future chan *Reply

+ func (f Future) Reply() (r *Reply)

+ type Message struct

+ Channel string

+ Error error

+ Pattern string

+ Payload string

+ Subscriptions int

+ Type MessageType

+ func (m *Message) String() string

+ type MessageType int

+ const MessageError

+ const MessageMessage

+ const MessagePMessage

+ const MessagePSubscribe

+ const MessagePUnsubscribe

+ const MessageSubscribe

+ const MessageUnsubscribe

+ type MultiCommand struct

+ func (mc *MultiCommand) Command(cmd string, args ...interface{})

+ func (mc *MultiCommand) Flush() *Reply

+ type Reply struct

+ func (r *Reply) At(i int) *Reply

+ func (r *Reply) Bool() bool

+ func (r *Reply) Bytes() []byte

+ func (r *Reply) Elems() []*Reply

+ func (r *Reply) Error() *Error

+ func (r *Reply) ErrorString() string

+ func (r *Reply) Int() int

+ func (r *Reply) Int64() int64

+ func (r *Reply) Len() int

+ func (r *Reply) Map() (map[string]*Reply, error)

+ func (r *Reply) Nil() bool

+ func (r *Reply) Str() string

+ func (r *Reply) String() string

+ func (r *Reply) StringMap() (map[string]string, error)

+ func (r *Reply) Strings() ([]string, error)

+ func (r *Reply) Type() ReplyType

+ type ReplyType uint8

+ const ReplyError

+ const ReplyInteger

+ const ReplyMulti

+ const ReplyNil

+ const ReplyStatus

+ const ReplyString

+ type Subscription struct

+ func (s *Subscription) Close()

+ func (s *Subscription) PSubscribe(patterns ...string) *Error

+ func (s *Subscription) PUnsubscribe(patterns ...string) *Error

+ func (s *Subscription) Subscribe(channels ...string) *Error

+ func (s *Subscription) Unsubscribe(channels ...string) *Error

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL