internal/cmds/gen_server.go
// Code generated DO NOT EDIT
package cmds
import "strconv"
type AclCat Incomplete
func (b Builder) AclCat() (c AclCat) {
c = AclCat{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "CAT")
return c
}
func (c AclCat) Categoryname(categoryname string) AclCatCategoryname {
c.cs.s = append(c.cs.s, categoryname)
return (AclCatCategoryname)(c)
}
func (c AclCat) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclCatCategoryname Incomplete
func (c AclCatCategoryname) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclDeluser Incomplete
func (b Builder) AclDeluser() (c AclDeluser) {
c = AclDeluser{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "DELUSER")
return c
}
func (c AclDeluser) Username(username ...string) AclDeluserUsername {
c.cs.s = append(c.cs.s, username...)
return (AclDeluserUsername)(c)
}
type AclDeluserUsername Incomplete
func (c AclDeluserUsername) Username(username ...string) AclDeluserUsername {
c.cs.s = append(c.cs.s, username...)
return c
}
func (c AclDeluserUsername) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclDryrun Incomplete
func (b Builder) AclDryrun() (c AclDryrun) {
c = AclDryrun{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "DRYRUN")
return c
}
func (c AclDryrun) Username(username string) AclDryrunUsername {
c.cs.s = append(c.cs.s, username)
return (AclDryrunUsername)(c)
}
type AclDryrunArg Incomplete
func (c AclDryrunArg) Arg(arg ...string) AclDryrunArg {
c.cs.s = append(c.cs.s, arg...)
return c
}
func (c AclDryrunArg) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclDryrunCommand Incomplete
func (c AclDryrunCommand) Arg(arg ...string) AclDryrunArg {
c.cs.s = append(c.cs.s, arg...)
return (AclDryrunArg)(c)
}
func (c AclDryrunCommand) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclDryrunUsername Incomplete
func (c AclDryrunUsername) Command(command string) AclDryrunCommand {
c.cs.s = append(c.cs.s, command)
return (AclDryrunCommand)(c)
}
type AclGenpass Incomplete
func (b Builder) AclGenpass() (c AclGenpass) {
c = AclGenpass{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "GENPASS")
return c
}
func (c AclGenpass) Bits(bits int64) AclGenpassBits {
c.cs.s = append(c.cs.s, strconv.FormatInt(bits, 10))
return (AclGenpassBits)(c)
}
func (c AclGenpass) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclGenpassBits Incomplete
func (c AclGenpassBits) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclGetuser Incomplete
func (b Builder) AclGetuser() (c AclGetuser) {
c = AclGetuser{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "GETUSER")
return c
}
func (c AclGetuser) Username(username string) AclGetuserUsername {
c.cs.s = append(c.cs.s, username)
return (AclGetuserUsername)(c)
}
type AclGetuserUsername Incomplete
func (c AclGetuserUsername) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclHelp Incomplete
func (b Builder) AclHelp() (c AclHelp) {
c = AclHelp{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "HELP")
return c
}
func (c AclHelp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclList Incomplete
func (b Builder) AclList() (c AclList) {
c = AclList{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "LIST")
return c
}
func (c AclList) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclLoad Incomplete
func (b Builder) AclLoad() (c AclLoad) {
c = AclLoad{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "LOAD")
return c
}
func (c AclLoad) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclLog Incomplete
func (b Builder) AclLog() (c AclLog) {
c = AclLog{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "LOG")
return c
}
func (c AclLog) Count(count int64) AclLogCountCount {
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
return (AclLogCountCount)(c)
}
func (c AclLog) Reset() AclLogCountReset {
c.cs.s = append(c.cs.s, "RESET")
return (AclLogCountReset)(c)
}
type AclLogCountCount Incomplete
func (c AclLogCountCount) Reset() AclLogCountReset {
c.cs.s = append(c.cs.s, "RESET")
return (AclLogCountReset)(c)
}
func (c AclLogCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclLogCountReset Incomplete
func (c AclLogCountReset) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclSave Incomplete
func (b Builder) AclSave() (c AclSave) {
c = AclSave{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "SAVE")
return c
}
func (c AclSave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclSetuser Incomplete
func (b Builder) AclSetuser() (c AclSetuser) {
c = AclSetuser{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "SETUSER")
return c
}
func (c AclSetuser) Username(username string) AclSetuserUsername {
c.cs.s = append(c.cs.s, username)
return (AclSetuserUsername)(c)
}
type AclSetuserRule Incomplete
func (c AclSetuserRule) Rule(rule ...string) AclSetuserRule {
c.cs.s = append(c.cs.s, rule...)
return c
}
func (c AclSetuserRule) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclSetuserUsername Incomplete
func (c AclSetuserUsername) Rule(rule ...string) AclSetuserRule {
c.cs.s = append(c.cs.s, rule...)
return (AclSetuserRule)(c)
}
func (c AclSetuserUsername) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclUsers Incomplete
func (b Builder) AclUsers() (c AclUsers) {
c = AclUsers{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "USERS")
return c
}
func (c AclUsers) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type AclWhoami Incomplete
func (b Builder) AclWhoami() (c AclWhoami) {
c = AclWhoami{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ACL", "WHOAMI")
return c
}
func (c AclWhoami) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Bgrewriteaof Incomplete
func (b Builder) Bgrewriteaof() (c Bgrewriteaof) {
c = Bgrewriteaof{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "BGREWRITEAOF")
return c
}
func (c Bgrewriteaof) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Bgsave Incomplete
func (b Builder) Bgsave() (c Bgsave) {
c = Bgsave{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "BGSAVE")
return c
}
func (c Bgsave) Schedule() BgsaveSchedule {
c.cs.s = append(c.cs.s, "SCHEDULE")
return (BgsaveSchedule)(c)
}
func (c Bgsave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type BgsaveSchedule Incomplete
func (c BgsaveSchedule) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Command Incomplete
func (b Builder) Command() (c Command) {
c = Command{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND")
return c
}
func (c Command) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandCount Incomplete
func (b Builder) CommandCount() (c CommandCount) {
c = CommandCount{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND", "COUNT")
return c
}
func (c CommandCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandDocs Incomplete
func (b Builder) CommandDocs() (c CommandDocs) {
c = CommandDocs{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND", "DOCS")
return c
}
func (c CommandDocs) CommandName(commandName ...string) CommandDocsCommandName {
c.cs.s = append(c.cs.s, commandName...)
return (CommandDocsCommandName)(c)
}
func (c CommandDocs) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandDocsCommandName Incomplete
func (c CommandDocsCommandName) CommandName(commandName ...string) CommandDocsCommandName {
c.cs.s = append(c.cs.s, commandName...)
return c
}
func (c CommandDocsCommandName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandGetkeys Incomplete
func (b Builder) CommandGetkeys() (c CommandGetkeys) {
c = CommandGetkeys{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND", "GETKEYS")
return c
}
func (c CommandGetkeys) Command(command string) CommandGetkeysCommand {
c.cs.s = append(c.cs.s, command)
return (CommandGetkeysCommand)(c)
}
type CommandGetkeysArg Incomplete
func (c CommandGetkeysArg) Arg(arg ...string) CommandGetkeysArg {
c.cs.s = append(c.cs.s, arg...)
return c
}
func (c CommandGetkeysArg) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandGetkeysCommand Incomplete
func (c CommandGetkeysCommand) Arg(arg ...string) CommandGetkeysArg {
c.cs.s = append(c.cs.s, arg...)
return (CommandGetkeysArg)(c)
}
func (c CommandGetkeysCommand) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandGetkeysandflags Incomplete
func (b Builder) CommandGetkeysandflags() (c CommandGetkeysandflags) {
c = CommandGetkeysandflags{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND", "GETKEYSANDFLAGS")
return c
}
func (c CommandGetkeysandflags) Command(command string) CommandGetkeysandflagsCommand {
c.cs.s = append(c.cs.s, command)
return (CommandGetkeysandflagsCommand)(c)
}
type CommandGetkeysandflagsArg Incomplete
func (c CommandGetkeysandflagsArg) Arg(arg ...string) CommandGetkeysandflagsArg {
c.cs.s = append(c.cs.s, arg...)
return c
}
func (c CommandGetkeysandflagsArg) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandGetkeysandflagsCommand Incomplete
func (c CommandGetkeysandflagsCommand) Arg(arg ...string) CommandGetkeysandflagsArg {
c.cs.s = append(c.cs.s, arg...)
return (CommandGetkeysandflagsArg)(c)
}
func (c CommandGetkeysandflagsCommand) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandInfo Incomplete
func (b Builder) CommandInfo() (c CommandInfo) {
c = CommandInfo{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND", "INFO")
return c
}
func (c CommandInfo) CommandName(commandName ...string) CommandInfoCommandName {
c.cs.s = append(c.cs.s, commandName...)
return (CommandInfoCommandName)(c)
}
func (c CommandInfo) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandInfoCommandName Incomplete
func (c CommandInfoCommandName) CommandName(commandName ...string) CommandInfoCommandName {
c.cs.s = append(c.cs.s, commandName...)
return c
}
func (c CommandInfoCommandName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandList Incomplete
func (b Builder) CommandList() (c CommandList) {
c = CommandList{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "COMMAND", "LIST")
return c
}
func (c CommandList) FilterbyModuleName(name string) CommandListFilterbyModuleName {
c.cs.s = append(c.cs.s, "FILTERBY", "MODULE", name)
return (CommandListFilterbyModuleName)(c)
}
func (c CommandList) FilterbyAclcatCategory(category string) CommandListFilterbyAclcatCategory {
c.cs.s = append(c.cs.s, "FILTERBY", "ACLCAT", category)
return (CommandListFilterbyAclcatCategory)(c)
}
func (c CommandList) FilterbyPatternPattern(pattern string) CommandListFilterbyPatternPattern {
c.cs.s = append(c.cs.s, "FILTERBY", "PATTERN", pattern)
return (CommandListFilterbyPatternPattern)(c)
}
func (c CommandList) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandListFilterbyAclcatCategory Incomplete
func (c CommandListFilterbyAclcatCategory) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandListFilterbyModuleName Incomplete
func (c CommandListFilterbyModuleName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type CommandListFilterbyPatternPattern Incomplete
func (c CommandListFilterbyPatternPattern) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ConfigGet Incomplete
func (b Builder) ConfigGet() (c ConfigGet) {
c = ConfigGet{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CONFIG", "GET")
return c
}
func (c ConfigGet) Parameter(parameter ...string) ConfigGetParameter {
c.cs.s = append(c.cs.s, parameter...)
return (ConfigGetParameter)(c)
}
type ConfigGetParameter Incomplete
func (c ConfigGetParameter) Parameter(parameter ...string) ConfigGetParameter {
c.cs.s = append(c.cs.s, parameter...)
return c
}
func (c ConfigGetParameter) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ConfigResetstat Incomplete
func (b Builder) ConfigResetstat() (c ConfigResetstat) {
c = ConfigResetstat{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CONFIG", "RESETSTAT")
return c
}
func (c ConfigResetstat) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ConfigRewrite Incomplete
func (b Builder) ConfigRewrite() (c ConfigRewrite) {
c = ConfigRewrite{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CONFIG", "REWRITE")
return c
}
func (c ConfigRewrite) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ConfigSet Incomplete
func (b Builder) ConfigSet() (c ConfigSet) {
c = ConfigSet{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "CONFIG", "SET")
return c
}
func (c ConfigSet) ParameterValue() ConfigSetParameterValue {
return (ConfigSetParameterValue)(c)
}
type ConfigSetParameterValue Incomplete
func (c ConfigSetParameterValue) ParameterValue(parameter string, value string) ConfigSetParameterValue {
c.cs.s = append(c.cs.s, parameter, value)
return c
}
func (c ConfigSetParameterValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Dbsize Incomplete
func (b Builder) Dbsize() (c Dbsize) {
c = Dbsize{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "DBSIZE")
return c
}
func (c Dbsize) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type DebugObject Incomplete
func (b Builder) DebugObject() (c DebugObject) {
c = DebugObject{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "DEBUG", "OBJECT")
return c
}
func (c DebugObject) Key(key string) DebugObjectKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (DebugObjectKey)(c)
}
type DebugObjectKey Incomplete
func (c DebugObjectKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type DebugSegfault Incomplete
func (b Builder) DebugSegfault() (c DebugSegfault) {
c = DebugSegfault{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "DEBUG", "SEGFAULT")
return c
}
func (c DebugSegfault) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Failover Incomplete
func (b Builder) Failover() (c Failover) {
c = Failover{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "FAILOVER")
return c
}
func (c Failover) To() FailoverTargetTo {
c.cs.s = append(c.cs.s, "TO")
return (FailoverTargetTo)(c)
}
func (c Failover) Abort() FailoverAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (FailoverAbort)(c)
}
func (c Failover) Timeout(milliseconds int64) FailoverTimeout {
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
return (FailoverTimeout)(c)
}
func (c Failover) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FailoverAbort Incomplete
func (c FailoverAbort) Timeout(milliseconds int64) FailoverTimeout {
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
return (FailoverTimeout)(c)
}
func (c FailoverAbort) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FailoverTargetForce Incomplete
func (c FailoverTargetForce) Abort() FailoverAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (FailoverAbort)(c)
}
func (c FailoverTargetForce) Timeout(milliseconds int64) FailoverTimeout {
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
return (FailoverTimeout)(c)
}
func (c FailoverTargetForce) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FailoverTargetHost Incomplete
func (c FailoverTargetHost) Port(port int64) FailoverTargetPort {
c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
return (FailoverTargetPort)(c)
}
type FailoverTargetPort Incomplete
func (c FailoverTargetPort) Force() FailoverTargetForce {
c.cs.s = append(c.cs.s, "FORCE")
return (FailoverTargetForce)(c)
}
func (c FailoverTargetPort) Abort() FailoverAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (FailoverAbort)(c)
}
func (c FailoverTargetPort) Timeout(milliseconds int64) FailoverTimeout {
c.cs.s = append(c.cs.s, "TIMEOUT", strconv.FormatInt(milliseconds, 10))
return (FailoverTimeout)(c)
}
func (c FailoverTargetPort) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FailoverTargetTo Incomplete
func (c FailoverTargetTo) Host(host string) FailoverTargetHost {
c.cs.s = append(c.cs.s, host)
return (FailoverTargetHost)(c)
}
type FailoverTimeout Incomplete
func (c FailoverTimeout) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Flushall Incomplete
func (b Builder) Flushall() (c Flushall) {
c = Flushall{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "FLUSHALL")
return c
}
func (c Flushall) Async() FlushallAsync {
c.cs.s = append(c.cs.s, "ASYNC")
return (FlushallAsync)(c)
}
func (c Flushall) Sync() FlushallAsyncSync {
c.cs.s = append(c.cs.s, "SYNC")
return (FlushallAsyncSync)(c)
}
func (c Flushall) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FlushallAsync Incomplete
func (c FlushallAsync) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FlushallAsyncSync Incomplete
func (c FlushallAsyncSync) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Flushdb Incomplete
func (b Builder) Flushdb() (c Flushdb) {
c = Flushdb{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "FLUSHDB")
return c
}
func (c Flushdb) Async() FlushdbAsync {
c.cs.s = append(c.cs.s, "ASYNC")
return (FlushdbAsync)(c)
}
func (c Flushdb) Sync() FlushdbAsyncSync {
c.cs.s = append(c.cs.s, "SYNC")
return (FlushdbAsyncSync)(c)
}
func (c Flushdb) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FlushdbAsync Incomplete
func (c FlushdbAsync) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type FlushdbAsyncSync Incomplete
func (c FlushdbAsyncSync) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Info Incomplete
func (b Builder) Info() (c Info) {
c = Info{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "INFO")
return c
}
func (c Info) Section(section ...string) InfoSection {
c.cs.s = append(c.cs.s, section...)
return (InfoSection)(c)
}
func (c Info) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type InfoSection Incomplete
func (c InfoSection) Section(section ...string) InfoSection {
c.cs.s = append(c.cs.s, section...)
return c
}
func (c InfoSection) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Lastsave Incomplete
func (b Builder) Lastsave() (c Lastsave) {
c = Lastsave{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LASTSAVE")
return c
}
func (c Lastsave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyDoctor Incomplete
func (b Builder) LatencyDoctor() (c LatencyDoctor) {
c = LatencyDoctor{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "DOCTOR")
return c
}
func (c LatencyDoctor) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyGraph Incomplete
func (b Builder) LatencyGraph() (c LatencyGraph) {
c = LatencyGraph{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "GRAPH")
return c
}
func (c LatencyGraph) Event(event string) LatencyGraphEvent {
c.cs.s = append(c.cs.s, event)
return (LatencyGraphEvent)(c)
}
type LatencyGraphEvent Incomplete
func (c LatencyGraphEvent) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyHelp Incomplete
func (b Builder) LatencyHelp() (c LatencyHelp) {
c = LatencyHelp{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "HELP")
return c
}
func (c LatencyHelp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyHistogram Incomplete
func (b Builder) LatencyHistogram() (c LatencyHistogram) {
c = LatencyHistogram{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "HISTOGRAM")
return c
}
func (c LatencyHistogram) Command(command ...string) LatencyHistogramCommand {
c.cs.s = append(c.cs.s, command...)
return (LatencyHistogramCommand)(c)
}
func (c LatencyHistogram) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyHistogramCommand Incomplete
func (c LatencyHistogramCommand) Command(command ...string) LatencyHistogramCommand {
c.cs.s = append(c.cs.s, command...)
return c
}
func (c LatencyHistogramCommand) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyHistory Incomplete
func (b Builder) LatencyHistory() (c LatencyHistory) {
c = LatencyHistory{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "HISTORY")
return c
}
func (c LatencyHistory) Event(event string) LatencyHistoryEvent {
c.cs.s = append(c.cs.s, event)
return (LatencyHistoryEvent)(c)
}
type LatencyHistoryEvent Incomplete
func (c LatencyHistoryEvent) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyLatest Incomplete
func (b Builder) LatencyLatest() (c LatencyLatest) {
c = LatencyLatest{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "LATEST")
return c
}
func (c LatencyLatest) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyReset Incomplete
func (b Builder) LatencyReset() (c LatencyReset) {
c = LatencyReset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "LATENCY", "RESET")
return c
}
func (c LatencyReset) Event(event ...string) LatencyResetEvent {
c.cs.s = append(c.cs.s, event...)
return (LatencyResetEvent)(c)
}
func (c LatencyReset) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LatencyResetEvent Incomplete
func (c LatencyResetEvent) Event(event ...string) LatencyResetEvent {
c.cs.s = append(c.cs.s, event...)
return c
}
func (c LatencyResetEvent) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Lolwut Incomplete
func (b Builder) Lolwut() (c Lolwut) {
c = Lolwut{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "LOLWUT")
return c
}
func (c Lolwut) Version(version int64) LolwutVersion {
c.cs.s = append(c.cs.s, "VERSION", strconv.FormatInt(version, 10))
return (LolwutVersion)(c)
}
func (c Lolwut) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LolwutVersion Incomplete
func (c LolwutVersion) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryDoctor Incomplete
func (b Builder) MemoryDoctor() (c MemoryDoctor) {
c = MemoryDoctor{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "MEMORY", "DOCTOR")
return c
}
func (c MemoryDoctor) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryHelp Incomplete
func (b Builder) MemoryHelp() (c MemoryHelp) {
c = MemoryHelp{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MEMORY", "HELP")
return c
}
func (c MemoryHelp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryMallocStats Incomplete
func (b Builder) MemoryMallocStats() (c MemoryMallocStats) {
c = MemoryMallocStats{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "MEMORY", "MALLOC-STATS")
return c
}
func (c MemoryMallocStats) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryPurge Incomplete
func (b Builder) MemoryPurge() (c MemoryPurge) {
c = MemoryPurge{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MEMORY", "PURGE")
return c
}
func (c MemoryPurge) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryStats Incomplete
func (b Builder) MemoryStats() (c MemoryStats) {
c = MemoryStats{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "MEMORY", "STATS")
return c
}
func (c MemoryStats) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryUsage Incomplete
func (b Builder) MemoryUsage() (c MemoryUsage) {
c = MemoryUsage{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "MEMORY", "USAGE")
return c
}
func (c MemoryUsage) Key(key string) MemoryUsageKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key)
} else {
c.ks = check(c.ks, slot(key))
}
c.cs.s = append(c.cs.s, key)
return (MemoryUsageKey)(c)
}
type MemoryUsageKey Incomplete
func (c MemoryUsageKey) Samples(count int64) MemoryUsageSamples {
c.cs.s = append(c.cs.s, "SAMPLES", strconv.FormatInt(count, 10))
return (MemoryUsageSamples)(c)
}
func (c MemoryUsageKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type MemoryUsageSamples Incomplete
func (c MemoryUsageSamples) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleList Incomplete
func (b Builder) ModuleList() (c ModuleList) {
c = ModuleList{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MODULE", "LIST")
return c
}
func (c ModuleList) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleLoad Incomplete
func (b Builder) ModuleLoad() (c ModuleLoad) {
c = ModuleLoad{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MODULE", "LOAD")
return c
}
func (c ModuleLoad) Path(path string) ModuleLoadPath {
c.cs.s = append(c.cs.s, path)
return (ModuleLoadPath)(c)
}
type ModuleLoadArg Incomplete
func (c ModuleLoadArg) Arg(arg ...string) ModuleLoadArg {
c.cs.s = append(c.cs.s, arg...)
return c
}
func (c ModuleLoadArg) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleLoadPath Incomplete
func (c ModuleLoadPath) Arg(arg ...string) ModuleLoadArg {
c.cs.s = append(c.cs.s, arg...)
return (ModuleLoadArg)(c)
}
func (c ModuleLoadPath) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleLoadex Incomplete
func (b Builder) ModuleLoadex() (c ModuleLoadex) {
c = ModuleLoadex{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MODULE", "LOADEX")
return c
}
func (c ModuleLoadex) Path(path string) ModuleLoadexPath {
c.cs.s = append(c.cs.s, path)
return (ModuleLoadexPath)(c)
}
type ModuleLoadexArgs Incomplete
func (c ModuleLoadexArgs) Args(args ...string) ModuleLoadexArgs {
c.cs.s = append(c.cs.s, "ARGS")
c.cs.s = append(c.cs.s, args...)
return c
}
func (c ModuleLoadexArgs) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleLoadexConfig Incomplete
func (c ModuleLoadexConfig) Config(name string, value string) ModuleLoadexConfig {
c.cs.s = append(c.cs.s, "CONFIG", name, value)
return c
}
func (c ModuleLoadexConfig) Args(args ...string) ModuleLoadexArgs {
c.cs.s = append(c.cs.s, "ARGS")
c.cs.s = append(c.cs.s, args...)
return (ModuleLoadexArgs)(c)
}
func (c ModuleLoadexConfig) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleLoadexPath Incomplete
func (c ModuleLoadexPath) Config() ModuleLoadexConfig {
return (ModuleLoadexConfig)(c)
}
func (c ModuleLoadexPath) Args(args ...string) ModuleLoadexArgs {
c.cs.s = append(c.cs.s, "ARGS")
c.cs.s = append(c.cs.s, args...)
return (ModuleLoadexArgs)(c)
}
func (c ModuleLoadexPath) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ModuleUnload Incomplete
func (b Builder) ModuleUnload() (c ModuleUnload) {
c = ModuleUnload{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MODULE", "UNLOAD")
return c
}
func (c ModuleUnload) Name(name string) ModuleUnloadName {
c.cs.s = append(c.cs.s, name)
return (ModuleUnloadName)(c)
}
type ModuleUnloadName Incomplete
func (c ModuleUnloadName) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Monitor Incomplete
func (b Builder) Monitor() (c Monitor) {
c = Monitor{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MONITOR")
return c
}
func (c Monitor) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Psync Incomplete
func (b Builder) Psync() (c Psync) {
c = Psync{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "PSYNC")
return c
}
func (c Psync) Replicationid(replicationid string) PsyncReplicationid {
c.cs.s = append(c.cs.s, replicationid)
return (PsyncReplicationid)(c)
}
type PsyncOffset Incomplete
func (c PsyncOffset) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type PsyncReplicationid Incomplete
func (c PsyncReplicationid) Offset(offset int64) PsyncOffset {
c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
return (PsyncOffset)(c)
}
type Replicaof Incomplete
func (b Builder) Replicaof() (c Replicaof) {
c = Replicaof{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "REPLICAOF")
return c
}
func (c Replicaof) Host(host string) ReplicaofArgsHostPortHost {
c.cs.s = append(c.cs.s, host)
return (ReplicaofArgsHostPortHost)(c)
}
func (c Replicaof) No() ReplicaofArgsNoOneNo {
c.cs.s = append(c.cs.s, "NO")
return (ReplicaofArgsNoOneNo)(c)
}
type ReplicaofArgsHostPortHost Incomplete
func (c ReplicaofArgsHostPortHost) Port(port int64) ReplicaofArgsHostPortPort {
c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
return (ReplicaofArgsHostPortPort)(c)
}
type ReplicaofArgsHostPortPort Incomplete
func (c ReplicaofArgsHostPortPort) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ReplicaofArgsNoOneNo Incomplete
func (c ReplicaofArgsNoOneNo) One() ReplicaofArgsNoOneOne {
c.cs.s = append(c.cs.s, "ONE")
return (ReplicaofArgsNoOneOne)(c)
}
type ReplicaofArgsNoOneOne Incomplete
func (c ReplicaofArgsNoOneOne) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Role Incomplete
func (b Builder) Role() (c Role) {
c = Role{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "ROLE")
return c
}
func (c Role) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Save Incomplete
func (b Builder) Save() (c Save) {
c = Save{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SAVE")
return c
}
func (c Save) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Shutdown Incomplete
func (b Builder) Shutdown() (c Shutdown) {
c = Shutdown{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SHUTDOWN")
return c
}
func (c Shutdown) Nosave() ShutdownSaveModeNosave {
c.cs.s = append(c.cs.s, "NOSAVE")
return (ShutdownSaveModeNosave)(c)
}
func (c Shutdown) Save() ShutdownSaveModeSave {
c.cs.s = append(c.cs.s, "SAVE")
return (ShutdownSaveModeSave)(c)
}
func (c Shutdown) Now() ShutdownNow {
c.cs.s = append(c.cs.s, "NOW")
return (ShutdownNow)(c)
}
func (c Shutdown) Force() ShutdownForce {
c.cs.s = append(c.cs.s, "FORCE")
return (ShutdownForce)(c)
}
func (c Shutdown) Abort() ShutdownAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (ShutdownAbort)(c)
}
func (c Shutdown) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ShutdownAbort Incomplete
func (c ShutdownAbort) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ShutdownForce Incomplete
func (c ShutdownForce) Abort() ShutdownAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (ShutdownAbort)(c)
}
func (c ShutdownForce) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ShutdownNow Incomplete
func (c ShutdownNow) Force() ShutdownForce {
c.cs.s = append(c.cs.s, "FORCE")
return (ShutdownForce)(c)
}
func (c ShutdownNow) Abort() ShutdownAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (ShutdownAbort)(c)
}
func (c ShutdownNow) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ShutdownSaveModeNosave Incomplete
func (c ShutdownSaveModeNosave) Now() ShutdownNow {
c.cs.s = append(c.cs.s, "NOW")
return (ShutdownNow)(c)
}
func (c ShutdownSaveModeNosave) Force() ShutdownForce {
c.cs.s = append(c.cs.s, "FORCE")
return (ShutdownForce)(c)
}
func (c ShutdownSaveModeNosave) Abort() ShutdownAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (ShutdownAbort)(c)
}
func (c ShutdownSaveModeNosave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type ShutdownSaveModeSave Incomplete
func (c ShutdownSaveModeSave) Now() ShutdownNow {
c.cs.s = append(c.cs.s, "NOW")
return (ShutdownNow)(c)
}
func (c ShutdownSaveModeSave) Force() ShutdownForce {
c.cs.s = append(c.cs.s, "FORCE")
return (ShutdownForce)(c)
}
func (c ShutdownSaveModeSave) Abort() ShutdownAbort {
c.cs.s = append(c.cs.s, "ABORT")
return (ShutdownAbort)(c)
}
func (c ShutdownSaveModeSave) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Slaveof Incomplete
func (b Builder) Slaveof() (c Slaveof) {
c = Slaveof{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SLAVEOF")
return c
}
func (c Slaveof) Host(host string) SlaveofArgsHostPortHost {
c.cs.s = append(c.cs.s, host)
return (SlaveofArgsHostPortHost)(c)
}
func (c Slaveof) No() SlaveofArgsNoOneNo {
c.cs.s = append(c.cs.s, "NO")
return (SlaveofArgsNoOneNo)(c)
}
type SlaveofArgsHostPortHost Incomplete
func (c SlaveofArgsHostPortHost) Port(port int64) SlaveofArgsHostPortPort {
c.cs.s = append(c.cs.s, strconv.FormatInt(port, 10))
return (SlaveofArgsHostPortPort)(c)
}
type SlaveofArgsHostPortPort Incomplete
func (c SlaveofArgsHostPortPort) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SlaveofArgsNoOneNo Incomplete
func (c SlaveofArgsNoOneNo) One() SlaveofArgsNoOneOne {
c.cs.s = append(c.cs.s, "ONE")
return (SlaveofArgsNoOneOne)(c)
}
type SlaveofArgsNoOneOne Incomplete
func (c SlaveofArgsNoOneOne) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SlowlogGet Incomplete
func (b Builder) SlowlogGet() (c SlowlogGet) {
c = SlowlogGet{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "SLOWLOG", "GET")
return c
}
func (c SlowlogGet) Count(count int64) SlowlogGetCount {
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
return (SlowlogGetCount)(c)
}
func (c SlowlogGet) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SlowlogGetCount Incomplete
func (c SlowlogGetCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SlowlogHelp Incomplete
func (b Builder) SlowlogHelp() (c SlowlogHelp) {
c = SlowlogHelp{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "SLOWLOG", "HELP")
return c
}
func (c SlowlogHelp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SlowlogLen Incomplete
func (b Builder) SlowlogLen() (c SlowlogLen) {
c = SlowlogLen{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "SLOWLOG", "LEN")
return c
}
func (c SlowlogLen) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SlowlogReset Incomplete
func (b Builder) SlowlogReset() (c SlowlogReset) {
c = SlowlogReset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SLOWLOG", "RESET")
return c
}
func (c SlowlogReset) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Swapdb Incomplete
func (b Builder) Swapdb() (c Swapdb) {
c = Swapdb{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SWAPDB")
return c
}
func (c Swapdb) Index1(index1 int64) SwapdbIndex1 {
c.cs.s = append(c.cs.s, strconv.FormatInt(index1, 10))
return (SwapdbIndex1)(c)
}
type SwapdbIndex1 Incomplete
func (c SwapdbIndex1) Index2(index2 int64) SwapdbIndex2 {
c.cs.s = append(c.cs.s, strconv.FormatInt(index2, 10))
return (SwapdbIndex2)(c)
}
type SwapdbIndex2 Incomplete
func (c SwapdbIndex2) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Sync Incomplete
func (b Builder) Sync() (c Sync) {
c = Sync{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SYNC")
return c
}
func (c Sync) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Time Incomplete
func (b Builder) Time() (c Time) {
c = Time{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TIME")
return c
}
func (c Time) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}