claude/mattermost-community-enterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
mattermost-community-enterp.../vendor/github.com/redis/rueidis/internal/cmds/gen_string.go
Claude ec1f89217a Merge: Complete Mattermost Server with Community Enterprise 
Full Mattermost server source with integrated Community Enterprise features.
Includes vendor directory for offline/air-gapped builds.

Structure:
- enterprise-impl/: Enterprise feature implementations
- enterprise-community/: Init files that register implementations
- enterprise/: Bridge imports (community_imports.go)
- vendor/: All dependencies for offline builds

Build (online):
  go build ./cmd/mattermost

Build (offline/air-gapped):
  go build -mod=vendor ./cmd/mattermost

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
2025-12-17 23:59:07 +09:00

1268 lines
31 KiB
Go
Raw Permalink Blame History

// Code generated DO NOT EDIT
package cmds
import (
"strconv"
"time"
)
type Append Incomplete
func (b Builder) Append() (c Append) {
c = Append{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "APPEND")
return c
}
func (c Append) Key(key string) AppendKey {
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 (AppendKey)(c)
}
type AppendKey Incomplete
func (c AppendKey) Value(value string) AppendValue {
c.cs.s = append(c.cs.s, value)
return (AppendValue)(c)
}
type AppendValue Incomplete
func (c AppendValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Decr Incomplete
func (b Builder) Decr() (c Decr) {
c = Decr{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "DECR")
return c
}
func (c Decr) Key(key string) DecrKey {
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 (DecrKey)(c)
}
type DecrKey Incomplete
func (c DecrKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Decrby Incomplete
func (b Builder) Decrby() (c Decrby) {
c = Decrby{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "DECRBY")
return c
}
func (c Decrby) Key(key string) DecrbyKey {
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 (DecrbyKey)(c)
}
type DecrbyDecrement Incomplete
func (c DecrbyDecrement) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type DecrbyKey Incomplete
func (c DecrbyKey) Decrement(decrement int64) DecrbyDecrement {
c.cs.s = append(c.cs.s, strconv.FormatInt(decrement, 10))
return (DecrbyDecrement)(c)
}
type Delifeq Incomplete
func (b Builder) Delifeq() (c Delifeq) {
c = Delifeq{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "DELIFEQ")
return c
}
func (c Delifeq) Key(key string) DelifeqKey {
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 (DelifeqKey)(c)
}
type DelifeqKey Incomplete
func (c DelifeqKey) Value(value string) DelifeqValue {
c.cs.s = append(c.cs.s, value)
return (DelifeqValue)(c)
}
type DelifeqValue Incomplete
func (c DelifeqValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Get Incomplete
func (b Builder) Get() (c Get) {
c = Get{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GET")
return c
}
func (c Get) Key(key string) GetKey {
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 (GetKey)(c)
}
type GetKey Incomplete
func (c GetKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GetKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Getdel Incomplete
func (b Builder) Getdel() (c Getdel) {
c = Getdel{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GETDEL")
return c
}
func (c Getdel) Key(key string) GetdelKey {
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 (GetdelKey)(c)
}
type GetdelKey Incomplete
func (c GetdelKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Getex Incomplete
func (b Builder) Getex() (c Getex) {
c = Getex{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GETEX")
return c
}
func (c Getex) Key(key string) GetexKey {
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 (GetexKey)(c)
}
type GetexExpirationExSecTyped Incomplete
func (c GetexExpirationExSecTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationExSeconds Incomplete
func (c GetexExpirationExSeconds) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationExatTimestamp Incomplete
func (c GetexExpirationExatTimestamp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationExatTimestampTyped Incomplete
func (c GetexExpirationExatTimestampTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationPersist Incomplete
func (c GetexExpirationPersist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationPxMilliseconds Incomplete
func (c GetexExpirationPxMilliseconds) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationPxMsTyped Incomplete
func (c GetexExpirationPxMsTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationPxatMillisecondsTimestamp Incomplete
func (c GetexExpirationPxatMillisecondsTimestamp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexExpirationPxatMsTimestampTyped Incomplete
func (c GetexExpirationPxatMsTimestampTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetexKey Incomplete
func (c GetexKey) ExSeconds(seconds int64) GetexExpirationExSeconds {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
return (GetexExpirationExSeconds)(c)
}
func (c GetexKey) PxMilliseconds(milliseconds int64) GetexExpirationPxMilliseconds {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
return (GetexExpirationPxMilliseconds)(c)
}
func (c GetexKey) ExatTimestamp(timestamp int64) GetexExpirationExatTimestamp {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
return (GetexExpirationExatTimestamp)(c)
}
func (c GetexKey) PxatMillisecondsTimestamp(millisecondsTimestamp int64) GetexExpirationPxatMillisecondsTimestamp {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
return (GetexExpirationPxatMillisecondsTimestamp)(c)
}
func (c GetexKey) Persist() GetexExpirationPersist {
c.cs.s = append(c.cs.s, "PERSIST")
return (GetexExpirationPersist)(c)
}
func (c GetexKey) Ex(duration time.Duration) GetexExpirationExSecTyped {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(int64(duration/time.Second), 10))
return (GetexExpirationExSecTyped)(c)
}
func (c GetexKey) Px(duration time.Duration) GetexExpirationPxMsTyped {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(int64(duration/time.Millisecond), 10))
return (GetexExpirationPxMsTyped)(c)
}
func (c GetexKey) Exat(timestamp time.Time) GetexExpirationExatTimestampTyped {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp.Unix(), 10))
return (GetexExpirationExatTimestampTyped)(c)
}
func (c GetexKey) Pxat(timestamp time.Time) GetexExpirationPxatMsTimestampTyped {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(timestamp.UnixMilli(), 10))
return (GetexExpirationPxatMsTimestampTyped)(c)
}
func (c GetexKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Getrange Incomplete
func (b Builder) Getrange() (c Getrange) {
c = Getrange{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GETRANGE")
return c
}
func (c Getrange) Key(key string) GetrangeKey {
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 (GetrangeKey)(c)
}
type GetrangeEnd Incomplete
func (c GetrangeEnd) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GetrangeEnd) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GetrangeKey Incomplete
func (c GetrangeKey) Start(start int64) GetrangeStart {
c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
return (GetrangeStart)(c)
}
type GetrangeStart Incomplete
func (c GetrangeStart) End(end int64) GetrangeEnd {
c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
return (GetrangeEnd)(c)
}
type Getset Incomplete
func (b Builder) Getset() (c Getset) {
c = Getset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GETSET")
return c
}
func (c Getset) Key(key string) GetsetKey {
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 (GetsetKey)(c)
}
type GetsetKey Incomplete
func (c GetsetKey) Value(value string) GetsetValue {
c.cs.s = append(c.cs.s, value)
return (GetsetValue)(c)
}
type GetsetValue Incomplete
func (c GetsetValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Incr Incomplete
func (b Builder) Incr() (c Incr) {
c = Incr{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "INCR")
return c
}
func (c Incr) Key(key string) IncrKey {
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 (IncrKey)(c)
}
type IncrKey Incomplete
func (c IncrKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Incrby Incomplete
func (b Builder) Incrby() (c Incrby) {
c = Incrby{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "INCRBY")
return c
}
func (c Incrby) Key(key string) IncrbyKey {
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 (IncrbyKey)(c)
}
type IncrbyIncrement Incomplete
func (c IncrbyIncrement) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type IncrbyKey Incomplete
func (c IncrbyKey) Increment(increment int64) IncrbyIncrement {
c.cs.s = append(c.cs.s, strconv.FormatInt(increment, 10))
return (IncrbyIncrement)(c)
}
type Incrbyfloat Incomplete
func (b Builder) Incrbyfloat() (c Incrbyfloat) {
c = Incrbyfloat{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "INCRBYFLOAT")
return c
}
func (c Incrbyfloat) Key(key string) IncrbyfloatKey {
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 (IncrbyfloatKey)(c)
}
type IncrbyfloatIncrement Incomplete
func (c IncrbyfloatIncrement) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type IncrbyfloatKey Incomplete
func (c IncrbyfloatKey) Increment(increment float64) IncrbyfloatIncrement {
c.cs.s = append(c.cs.s, strconv.FormatFloat(increment, 'f', -1, 64))
return (IncrbyfloatIncrement)(c)
}
type Lcs Incomplete
func (b Builder) Lcs() (c Lcs) {
c = Lcs{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "LCS")
return c
}
func (c Lcs) Key1(key1 string) LcsKey1 {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key1)
} else {
c.ks = check(c.ks, slot(key1))
}
c.cs.s = append(c.cs.s, key1)
return (LcsKey1)(c)
}
type LcsIdx Incomplete
func (c LcsIdx) Minmatchlen(len int64) LcsMinmatchlen {
c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
return (LcsMinmatchlen)(c)
}
func (c LcsIdx) Withmatchlen() LcsWithmatchlen {
c.cs.s = append(c.cs.s, "WITHMATCHLEN")
return (LcsWithmatchlen)(c)
}
func (c LcsIdx) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LcsKey1 Incomplete
func (c LcsKey1) Key2(key2 string) LcsKey2 {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(key2)
} else {
c.ks = check(c.ks, slot(key2))
}
c.cs.s = append(c.cs.s, key2)
return (LcsKey2)(c)
}
type LcsKey2 Incomplete
func (c LcsKey2) Len() LcsLen {
c.cs.s = append(c.cs.s, "LEN")
return (LcsLen)(c)
}
func (c LcsKey2) Idx() LcsIdx {
c.cs.s = append(c.cs.s, "IDX")
return (LcsIdx)(c)
}
func (c LcsKey2) Minmatchlen(len int64) LcsMinmatchlen {
c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
return (LcsMinmatchlen)(c)
}
func (c LcsKey2) Withmatchlen() LcsWithmatchlen {
c.cs.s = append(c.cs.s, "WITHMATCHLEN")
return (LcsWithmatchlen)(c)
}
func (c LcsKey2) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LcsLen Incomplete
func (c LcsLen) Idx() LcsIdx {
c.cs.s = append(c.cs.s, "IDX")
return (LcsIdx)(c)
}
func (c LcsLen) Minmatchlen(len int64) LcsMinmatchlen {
c.cs.s = append(c.cs.s, "MINMATCHLEN", strconv.FormatInt(len, 10))
return (LcsMinmatchlen)(c)
}
func (c LcsLen) Withmatchlen() LcsWithmatchlen {
c.cs.s = append(c.cs.s, "WITHMATCHLEN")
return (LcsWithmatchlen)(c)
}
func (c LcsLen) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LcsMinmatchlen Incomplete
func (c LcsMinmatchlen) Withmatchlen() LcsWithmatchlen {
c.cs.s = append(c.cs.s, "WITHMATCHLEN")
return (LcsWithmatchlen)(c)
}
func (c LcsMinmatchlen) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type LcsWithmatchlen Incomplete
func (c LcsWithmatchlen) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Mget Incomplete
func (b Builder) Mget() (c Mget) {
c = Mget{cs: get(), ks: b.ks, cf: int16(mtGetTag)}
c.cs.s = append(c.cs.s, "MGET")
return c
}
func (c Mget) Key(key ...string) MgetKey {
if c.ks&NoSlot == NoSlot {
for _, k := range key {
c.ks = NoSlot | slot(k)
break
}
} else {
for _, k := range key {
c.ks = check(c.ks, slot(k))
}
}
c.cs.s = append(c.cs.s, key...)
return (MgetKey)(c)
}
type MgetKey Incomplete
func (c MgetKey) Key(key ...string) MgetKey {
if c.ks&NoSlot == NoSlot {
for _, k := range key {
c.ks = NoSlot | slot(k)
break
}
} else {
for _, k := range key {
c.ks = check(c.ks, slot(k))
}
}
c.cs.s = append(c.cs.s, key...)
return c
}
func (c MgetKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c MgetKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Mset Incomplete
func (b Builder) Mset() (c Mset) {
c = Mset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MSET")
return c
}
func (c Mset) KeyValue() MsetKeyValue {
return (MsetKeyValue)(c)
}
type MsetKeyValue Incomplete
func (c MsetKeyValue) KeyValue(key string, value string) MsetKeyValue {
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, value)
return c
}
func (c MsetKeyValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Msetnx Incomplete
func (b Builder) Msetnx() (c Msetnx) {
c = Msetnx{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "MSETNX")
return c
}
func (c Msetnx) KeyValue() MsetnxKeyValue {
return (MsetnxKeyValue)(c)
}
type MsetnxKeyValue Incomplete
func (c MsetnxKeyValue) KeyValue(key string, value string) MsetnxKeyValue {
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, value)
return c
}
func (c MsetnxKeyValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Psetex Incomplete
func (b Builder) Psetex() (c Psetex) {
c = Psetex{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "PSETEX")
return c
}
func (c Psetex) Key(key string) PsetexKey {
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 (PsetexKey)(c)
}
type PsetexKey Incomplete
func (c PsetexKey) Milliseconds(milliseconds int64) PsetexMilliseconds {
c.cs.s = append(c.cs.s, strconv.FormatInt(milliseconds, 10))
return (PsetexMilliseconds)(c)
}
type PsetexMilliseconds Incomplete
func (c PsetexMilliseconds) Value(value string) PsetexValue {
c.cs.s = append(c.cs.s, value)
return (PsetexValue)(c)
}
type PsetexValue Incomplete
func (c PsetexValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Set Incomplete
func (b Builder) Set() (c Set) {
c = Set{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SET")
return c
}
func (c Set) Key(key string) SetKey {
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 (SetKey)(c)
}
type SetConditionIfeq Incomplete
func (c SetConditionIfeq) Get() SetGet {
c.cs.s = append(c.cs.s, "GET")
return (SetGet)(c)
}
func (c SetConditionIfeq) ExSeconds(seconds int64) SetExpirationExSeconds {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
return (SetExpirationExSeconds)(c)
}
func (c SetConditionIfeq) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
return (SetExpirationPxMilliseconds)(c)
}
func (c SetConditionIfeq) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
return (SetExpirationExatTimestamp)(c)
}
func (c SetConditionIfeq) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
return (SetExpirationPxatMillisecondsTimestamp)(c)
}
func (c SetConditionIfeq) Keepttl() SetExpirationKeepttl {
c.cs.s = append(c.cs.s, "KEEPTTL")
return (SetExpirationKeepttl)(c)
}
func (c SetConditionIfeq) Ex(duration time.Duration) SetExpirationExSecTyped {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(int64(duration/time.Second), 10))
return (SetExpirationExSecTyped)(c)
}
func (c SetConditionIfeq) Px(duration time.Duration) SetExpirationPxMsTyped {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(int64(duration/time.Millisecond), 10))
return (SetExpirationPxMsTyped)(c)
}
func (c SetConditionIfeq) Exat(timestamp time.Time) SetExpirationExatTimestampTyped {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp.Unix(), 10))
return (SetExpirationExatTimestampTyped)(c)
}
func (c SetConditionIfeq) Pxat(timestamp time.Time) SetExpirationPxatMsTimestampTyped {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(timestamp.UnixMilli(), 10))
return (SetExpirationPxatMsTimestampTyped)(c)
}
func (c SetConditionIfeq) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetConditionNx Incomplete
func (c SetConditionNx) Get() SetGet {
c.cs.s = append(c.cs.s, "GET")
return (SetGet)(c)
}
func (c SetConditionNx) ExSeconds(seconds int64) SetExpirationExSeconds {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
return (SetExpirationExSeconds)(c)
}
func (c SetConditionNx) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
return (SetExpirationPxMilliseconds)(c)
}
func (c SetConditionNx) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
return (SetExpirationExatTimestamp)(c)
}
func (c SetConditionNx) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
return (SetExpirationPxatMillisecondsTimestamp)(c)
}
func (c SetConditionNx) Keepttl() SetExpirationKeepttl {
c.cs.s = append(c.cs.s, "KEEPTTL")
return (SetExpirationKeepttl)(c)
}
func (c SetConditionNx) Ex(duration time.Duration) SetExpirationExSecTyped {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(int64(duration/time.Second), 10))
return (SetExpirationExSecTyped)(c)
}
func (c SetConditionNx) Px(duration time.Duration) SetExpirationPxMsTyped {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(int64(duration/time.Millisecond), 10))
return (SetExpirationPxMsTyped)(c)
}
func (c SetConditionNx) Exat(timestamp time.Time) SetExpirationExatTimestampTyped {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp.Unix(), 10))
return (SetExpirationExatTimestampTyped)(c)
}
func (c SetConditionNx) Pxat(timestamp time.Time) SetExpirationPxatMsTimestampTyped {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(timestamp.UnixMilli(), 10))
return (SetExpirationPxatMsTimestampTyped)(c)
}
func (c SetConditionNx) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetConditionXx Incomplete
func (c SetConditionXx) Get() SetGet {
c.cs.s = append(c.cs.s, "GET")
return (SetGet)(c)
}
func (c SetConditionXx) ExSeconds(seconds int64) SetExpirationExSeconds {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
return (SetExpirationExSeconds)(c)
}
func (c SetConditionXx) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
return (SetExpirationPxMilliseconds)(c)
}
func (c SetConditionXx) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
return (SetExpirationExatTimestamp)(c)
}
func (c SetConditionXx) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
return (SetExpirationPxatMillisecondsTimestamp)(c)
}
func (c SetConditionXx) Keepttl() SetExpirationKeepttl {
c.cs.s = append(c.cs.s, "KEEPTTL")
return (SetExpirationKeepttl)(c)
}
func (c SetConditionXx) Ex(duration time.Duration) SetExpirationExSecTyped {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(int64(duration/time.Second), 10))
return (SetExpirationExSecTyped)(c)
}
func (c SetConditionXx) Px(duration time.Duration) SetExpirationPxMsTyped {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(int64(duration/time.Millisecond), 10))
return (SetExpirationPxMsTyped)(c)
}
func (c SetConditionXx) Exat(timestamp time.Time) SetExpirationExatTimestampTyped {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp.Unix(), 10))
return (SetExpirationExatTimestampTyped)(c)
}
func (c SetConditionXx) Pxat(timestamp time.Time) SetExpirationPxatMsTimestampTyped {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(timestamp.UnixMilli(), 10))
return (SetExpirationPxatMsTimestampTyped)(c)
}
func (c SetConditionXx) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationExSecTyped Incomplete
func (c SetExpirationExSecTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationExSeconds Incomplete
func (c SetExpirationExSeconds) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationExatTimestamp Incomplete
func (c SetExpirationExatTimestamp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationExatTimestampTyped Incomplete
func (c SetExpirationExatTimestampTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationKeepttl Incomplete
func (c SetExpirationKeepttl) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationPxMilliseconds Incomplete
func (c SetExpirationPxMilliseconds) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationPxMsTyped Incomplete
func (c SetExpirationPxMsTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationPxatMillisecondsTimestamp Incomplete
func (c SetExpirationPxatMillisecondsTimestamp) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetExpirationPxatMsTimestampTyped Incomplete
func (c SetExpirationPxatMsTimestampTyped) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetGet Incomplete
func (c SetGet) ExSeconds(seconds int64) SetExpirationExSeconds {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
return (SetExpirationExSeconds)(c)
}
func (c SetGet) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
return (SetExpirationPxMilliseconds)(c)
}
func (c SetGet) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
return (SetExpirationExatTimestamp)(c)
}
func (c SetGet) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
return (SetExpirationPxatMillisecondsTimestamp)(c)
}
func (c SetGet) Keepttl() SetExpirationKeepttl {
c.cs.s = append(c.cs.s, "KEEPTTL")
return (SetExpirationKeepttl)(c)
}
func (c SetGet) Ex(duration time.Duration) SetExpirationExSecTyped {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(int64(duration/time.Second), 10))
return (SetExpirationExSecTyped)(c)
}
func (c SetGet) Px(duration time.Duration) SetExpirationPxMsTyped {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(int64(duration/time.Millisecond), 10))
return (SetExpirationPxMsTyped)(c)
}
func (c SetGet) Exat(timestamp time.Time) SetExpirationExatTimestampTyped {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp.Unix(), 10))
return (SetExpirationExatTimestampTyped)(c)
}
func (c SetGet) Pxat(timestamp time.Time) SetExpirationPxatMsTimestampTyped {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(timestamp.UnixMilli(), 10))
return (SetExpirationPxatMsTimestampTyped)(c)
}
func (c SetGet) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type SetKey Incomplete
func (c SetKey) Value(value string) SetValue {
c.cs.s = append(c.cs.s, value)
return (SetValue)(c)
}
type SetValue Incomplete
func (c SetValue) Nx() SetConditionNx {
c.cs.s = append(c.cs.s, "NX")
return (SetConditionNx)(c)
}
func (c SetValue) Xx() SetConditionXx {
c.cs.s = append(c.cs.s, "XX")
return (SetConditionXx)(c)
}
func (c SetValue) Ifeq(ifeq string) SetConditionIfeq {
c.cs.s = append(c.cs.s, "IFEQ", ifeq)
return (SetConditionIfeq)(c)
}
func (c SetValue) Get() SetGet {
c.cs.s = append(c.cs.s, "GET")
return (SetGet)(c)
}
func (c SetValue) ExSeconds(seconds int64) SetExpirationExSeconds {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(seconds, 10))
return (SetExpirationExSeconds)(c)
}
func (c SetValue) PxMilliseconds(milliseconds int64) SetExpirationPxMilliseconds {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(milliseconds, 10))
return (SetExpirationPxMilliseconds)(c)
}
func (c SetValue) ExatTimestamp(timestamp int64) SetExpirationExatTimestamp {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp, 10))
return (SetExpirationExatTimestamp)(c)
}
func (c SetValue) PxatMillisecondsTimestamp(millisecondsTimestamp int64) SetExpirationPxatMillisecondsTimestamp {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(millisecondsTimestamp, 10))
return (SetExpirationPxatMillisecondsTimestamp)(c)
}
func (c SetValue) Keepttl() SetExpirationKeepttl {
c.cs.s = append(c.cs.s, "KEEPTTL")
return (SetExpirationKeepttl)(c)
}
func (c SetValue) Ex(duration time.Duration) SetExpirationExSecTyped {
c.cs.s = append(c.cs.s, "EX", strconv.FormatInt(int64(duration/time.Second), 10))
return (SetExpirationExSecTyped)(c)
}
func (c SetValue) Px(duration time.Duration) SetExpirationPxMsTyped {
c.cs.s = append(c.cs.s, "PX", strconv.FormatInt(int64(duration/time.Millisecond), 10))
return (SetExpirationPxMsTyped)(c)
}
func (c SetValue) Exat(timestamp time.Time) SetExpirationExatTimestampTyped {
c.cs.s = append(c.cs.s, "EXAT", strconv.FormatInt(timestamp.Unix(), 10))
return (SetExpirationExatTimestampTyped)(c)
}
func (c SetValue) Pxat(timestamp time.Time) SetExpirationPxatMsTimestampTyped {
c.cs.s = append(c.cs.s, "PXAT", strconv.FormatInt(timestamp.UnixMilli(), 10))
return (SetExpirationPxatMsTimestampTyped)(c)
}
func (c SetValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Setex Incomplete
func (b Builder) Setex() (c Setex) {
c = Setex{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SETEX")
return c
}
func (c Setex) Key(key string) SetexKey {
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 (SetexKey)(c)
}
type SetexKey Incomplete
func (c SetexKey) Seconds(seconds int64) SetexSeconds {
c.cs.s = append(c.cs.s, strconv.FormatInt(seconds, 10))
return (SetexSeconds)(c)
}
type SetexSeconds Incomplete
func (c SetexSeconds) Value(value string) SetexValue {
c.cs.s = append(c.cs.s, value)
return (SetexValue)(c)
}
type SetexValue Incomplete
func (c SetexValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Setnx Incomplete
func (b Builder) Setnx() (c Setnx) {
c = Setnx{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SETNX")
return c
}
func (c Setnx) Key(key string) SetnxKey {
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 (SetnxKey)(c)
}
type SetnxKey Incomplete
func (c SetnxKey) Value(value string) SetnxValue {
c.cs.s = append(c.cs.s, value)
return (SetnxValue)(c)
}
type SetnxValue Incomplete
func (c SetnxValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Setrange Incomplete
func (b Builder) Setrange() (c Setrange) {
c = Setrange{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "SETRANGE")
return c
}
func (c Setrange) Key(key string) SetrangeKey {
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 (SetrangeKey)(c)
}
type SetrangeKey Incomplete
func (c SetrangeKey) Offset(offset int64) SetrangeOffset {
c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
return (SetrangeOffset)(c)
}
type SetrangeOffset Incomplete
func (c SetrangeOffset) Value(value string) SetrangeValue {
c.cs.s = append(c.cs.s, value)
return (SetrangeValue)(c)
}
type SetrangeValue Incomplete
func (c SetrangeValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Strlen Incomplete
func (b Builder) Strlen() (c Strlen) {
c = Strlen{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "STRLEN")
return c
}
func (c Strlen) Key(key string) StrlenKey {
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 (StrlenKey)(c)
}
type StrlenKey Incomplete
func (c StrlenKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c StrlenKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
Reference in New Issue View Git Blame Copy Permalink