ec1f89217a
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>
711 lines
19 KiB
Go
711 lines
19 KiB
Go
// Code generated DO NOT EDIT
|
|
|
|
package cmds
|
|
|
|
import "strconv"
|
|
|
|
type Bitcount Incomplete
|
|
|
|
func (b Builder) Bitcount() (c Bitcount) {
|
|
c = Bitcount{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "BITCOUNT")
|
|
return c
|
|
}
|
|
|
|
func (c Bitcount) Key(key string) BitcountKey {
|
|
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 (BitcountKey)(c)
|
|
}
|
|
|
|
type BitcountIndexEnd Incomplete
|
|
|
|
func (c BitcountIndexEnd) Byte() BitcountIndexIndexUnitByte {
|
|
c.cs.s = append(c.cs.s, "BYTE")
|
|
return (BitcountIndexIndexUnitByte)(c)
|
|
}
|
|
|
|
func (c BitcountIndexEnd) Bit() BitcountIndexIndexUnitBit {
|
|
c.cs.s = append(c.cs.s, "BIT")
|
|
return (BitcountIndexIndexUnitBit)(c)
|
|
}
|
|
|
|
func (c BitcountIndexEnd) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitcountIndexEnd) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitcountIndexIndexUnitBit Incomplete
|
|
|
|
func (c BitcountIndexIndexUnitBit) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitcountIndexIndexUnitBit) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitcountIndexIndexUnitByte Incomplete
|
|
|
|
func (c BitcountIndexIndexUnitByte) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitcountIndexIndexUnitByte) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitcountIndexStart Incomplete
|
|
|
|
func (c BitcountIndexStart) End(end int64) BitcountIndexEnd {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
|
|
return (BitcountIndexEnd)(c)
|
|
}
|
|
|
|
type BitcountKey Incomplete
|
|
|
|
func (c BitcountKey) Start(start int64) BitcountIndexStart {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
|
|
return (BitcountIndexStart)(c)
|
|
}
|
|
|
|
func (c BitcountKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitcountKey) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Bitfield Incomplete
|
|
|
|
func (b Builder) Bitfield() (c Bitfield) {
|
|
c = Bitfield{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "BITFIELD")
|
|
return c
|
|
}
|
|
|
|
func (c Bitfield) Key(key string) BitfieldKey {
|
|
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 (BitfieldKey)(c)
|
|
}
|
|
|
|
type BitfieldKey Incomplete
|
|
|
|
func (c BitfieldKey) Get(encoding string, offset int64) BitfieldOperationGet {
|
|
c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
|
|
return (BitfieldOperationGet)(c)
|
|
}
|
|
|
|
func (c BitfieldKey) OverflowWrap() BitfieldOperationWriteOverflowWrap {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
|
|
return (BitfieldOperationWriteOverflowWrap)(c)
|
|
}
|
|
|
|
func (c BitfieldKey) OverflowSat() BitfieldOperationWriteOverflowSat {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
|
|
return (BitfieldOperationWriteOverflowSat)(c)
|
|
}
|
|
|
|
func (c BitfieldKey) OverflowFail() BitfieldOperationWriteOverflowFail {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
|
|
return (BitfieldOperationWriteOverflowFail)(c)
|
|
}
|
|
|
|
func (c BitfieldKey) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return (BitfieldOperationWriteSetSet)(c)
|
|
}
|
|
|
|
func (c BitfieldKey) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return (BitfieldOperationWriteSetIncrby)(c)
|
|
}
|
|
|
|
func (c BitfieldKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitfieldOperationGet Incomplete
|
|
|
|
func (c BitfieldOperationGet) OverflowWrap() BitfieldOperationWriteOverflowWrap {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
|
|
return (BitfieldOperationWriteOverflowWrap)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationGet) OverflowSat() BitfieldOperationWriteOverflowSat {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
|
|
return (BitfieldOperationWriteOverflowSat)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationGet) OverflowFail() BitfieldOperationWriteOverflowFail {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
|
|
return (BitfieldOperationWriteOverflowFail)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationGet) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return (BitfieldOperationWriteSetSet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationGet) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return (BitfieldOperationWriteSetIncrby)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationGet) Get(encoding string, offset int64) BitfieldOperationGet {
|
|
c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
|
|
return c
|
|
}
|
|
|
|
func (c BitfieldOperationGet) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitfieldOperationWriteOverflowFail Incomplete
|
|
|
|
func (c BitfieldOperationWriteOverflowFail) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return (BitfieldOperationWriteSetSet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteOverflowFail) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return (BitfieldOperationWriteSetIncrby)(c)
|
|
}
|
|
|
|
type BitfieldOperationWriteOverflowSat Incomplete
|
|
|
|
func (c BitfieldOperationWriteOverflowSat) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return (BitfieldOperationWriteSetSet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteOverflowSat) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return (BitfieldOperationWriteSetIncrby)(c)
|
|
}
|
|
|
|
type BitfieldOperationWriteOverflowWrap Incomplete
|
|
|
|
func (c BitfieldOperationWriteOverflowWrap) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return (BitfieldOperationWriteSetSet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteOverflowWrap) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return (BitfieldOperationWriteSetIncrby)(c)
|
|
}
|
|
|
|
type BitfieldOperationWriteSetIncrby Incomplete
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) Get(encoding string, offset int64) BitfieldOperationGet {
|
|
c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
|
|
return (BitfieldOperationGet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) OverflowWrap() BitfieldOperationWriteOverflowWrap {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
|
|
return (BitfieldOperationWriteOverflowWrap)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) OverflowSat() BitfieldOperationWriteOverflowSat {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
|
|
return (BitfieldOperationWriteOverflowSat)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) OverflowFail() BitfieldOperationWriteOverflowFail {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
|
|
return (BitfieldOperationWriteOverflowFail)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return (BitfieldOperationWriteSetSet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return c
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetIncrby) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitfieldOperationWriteSetSet Incomplete
|
|
|
|
func (c BitfieldOperationWriteSetSet) Incrby(encoding string, offset int64, increment int64) BitfieldOperationWriteSetIncrby {
|
|
c.cs.s = append(c.cs.s, "INCRBY", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(increment, 10))
|
|
return (BitfieldOperationWriteSetIncrby)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetSet) Get(encoding string, offset int64) BitfieldOperationGet {
|
|
c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
|
|
return (BitfieldOperationGet)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetSet) OverflowWrap() BitfieldOperationWriteOverflowWrap {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "WRAP")
|
|
return (BitfieldOperationWriteOverflowWrap)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetSet) OverflowSat() BitfieldOperationWriteOverflowSat {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "SAT")
|
|
return (BitfieldOperationWriteOverflowSat)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetSet) OverflowFail() BitfieldOperationWriteOverflowFail {
|
|
c.cs.s = append(c.cs.s, "OVERFLOW", "FAIL")
|
|
return (BitfieldOperationWriteOverflowFail)(c)
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetSet) Set(encoding string, offset int64, value int64) BitfieldOperationWriteSetSet {
|
|
c.cs.s = append(c.cs.s, "SET", encoding, strconv.FormatInt(offset, 10), strconv.FormatInt(value, 10))
|
|
return c
|
|
}
|
|
|
|
func (c BitfieldOperationWriteSetSet) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitfieldRo Incomplete
|
|
|
|
func (b Builder) BitfieldRo() (c BitfieldRo) {
|
|
c = BitfieldRo{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "BITFIELD_RO")
|
|
return c
|
|
}
|
|
|
|
func (c BitfieldRo) Key(key string) BitfieldRoKey {
|
|
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 (BitfieldRoKey)(c)
|
|
}
|
|
|
|
type BitfieldRoGet Incomplete
|
|
|
|
func (c BitfieldRoGet) Get(encoding string, offset int64) BitfieldRoGet {
|
|
c.cs.s = append(c.cs.s, "GET", encoding, strconv.FormatInt(offset, 10))
|
|
return c
|
|
}
|
|
|
|
func (c BitfieldRoGet) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitfieldRoGet) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitfieldRoKey Incomplete
|
|
|
|
func (c BitfieldRoKey) Get() BitfieldRoGet {
|
|
return (BitfieldRoGet)(c)
|
|
}
|
|
|
|
func (c BitfieldRoKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitfieldRoKey) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Bitop Incomplete
|
|
|
|
func (b Builder) Bitop() (c Bitop) {
|
|
c = Bitop{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "BITOP")
|
|
return c
|
|
}
|
|
|
|
func (c Bitop) And() BitopOperationAnd {
|
|
c.cs.s = append(c.cs.s, "AND")
|
|
return (BitopOperationAnd)(c)
|
|
}
|
|
|
|
func (c Bitop) Or() BitopOperationOr {
|
|
c.cs.s = append(c.cs.s, "OR")
|
|
return (BitopOperationOr)(c)
|
|
}
|
|
|
|
func (c Bitop) Xor() BitopOperationXor {
|
|
c.cs.s = append(c.cs.s, "XOR")
|
|
return (BitopOperationXor)(c)
|
|
}
|
|
|
|
func (c Bitop) Not() BitopOperationNot {
|
|
c.cs.s = append(c.cs.s, "NOT")
|
|
return (BitopOperationNot)(c)
|
|
}
|
|
|
|
func (c Bitop) Diff() BitopOperationDiff {
|
|
c.cs.s = append(c.cs.s, "DIFF")
|
|
return (BitopOperationDiff)(c)
|
|
}
|
|
|
|
func (c Bitop) Diff1() BitopOperationDiff1 {
|
|
c.cs.s = append(c.cs.s, "DIFF1")
|
|
return (BitopOperationDiff1)(c)
|
|
}
|
|
|
|
func (c Bitop) Andor() BitopOperationAndor {
|
|
c.cs.s = append(c.cs.s, "ANDOR")
|
|
return (BitopOperationAndor)(c)
|
|
}
|
|
|
|
func (c Bitop) One() BitopOperationOne {
|
|
c.cs.s = append(c.cs.s, "ONE")
|
|
return (BitopOperationOne)(c)
|
|
}
|
|
|
|
type BitopDestkey Incomplete
|
|
|
|
func (c BitopDestkey) Key(key ...string) BitopKey {
|
|
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 (BitopKey)(c)
|
|
}
|
|
|
|
type BitopKey Incomplete
|
|
|
|
func (c BitopKey) Key(key ...string) BitopKey {
|
|
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 BitopKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitopOperationAnd Incomplete
|
|
|
|
func (c BitopOperationAnd) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationAndor Incomplete
|
|
|
|
func (c BitopOperationAndor) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationDiff Incomplete
|
|
|
|
func (c BitopOperationDiff) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationDiff1 Incomplete
|
|
|
|
func (c BitopOperationDiff1) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationNot Incomplete
|
|
|
|
func (c BitopOperationNot) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationOne Incomplete
|
|
|
|
func (c BitopOperationOne) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationOr Incomplete
|
|
|
|
func (c BitopOperationOr) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type BitopOperationXor Incomplete
|
|
|
|
func (c BitopOperationXor) Destkey(destkey string) BitopDestkey {
|
|
if c.ks&NoSlot == NoSlot {
|
|
c.ks = NoSlot | slot(destkey)
|
|
} else {
|
|
c.ks = check(c.ks, slot(destkey))
|
|
}
|
|
c.cs.s = append(c.cs.s, destkey)
|
|
return (BitopDestkey)(c)
|
|
}
|
|
|
|
type Bitpos Incomplete
|
|
|
|
func (b Builder) Bitpos() (c Bitpos) {
|
|
c = Bitpos{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "BITPOS")
|
|
return c
|
|
}
|
|
|
|
func (c Bitpos) Key(key string) BitposKey {
|
|
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 (BitposKey)(c)
|
|
}
|
|
|
|
type BitposBit Incomplete
|
|
|
|
func (c BitposBit) Start(start int64) BitposIndexStart {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(start, 10))
|
|
return (BitposIndexStart)(c)
|
|
}
|
|
|
|
func (c BitposBit) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitposBit) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitposIndexEndIndexEnd Incomplete
|
|
|
|
func (c BitposIndexEndIndexEnd) Byte() BitposIndexEndIndexIndexUnitByte {
|
|
c.cs.s = append(c.cs.s, "BYTE")
|
|
return (BitposIndexEndIndexIndexUnitByte)(c)
|
|
}
|
|
|
|
func (c BitposIndexEndIndexEnd) Bit() BitposIndexEndIndexIndexUnitBit {
|
|
c.cs.s = append(c.cs.s, "BIT")
|
|
return (BitposIndexEndIndexIndexUnitBit)(c)
|
|
}
|
|
|
|
func (c BitposIndexEndIndexEnd) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitposIndexEndIndexEnd) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitposIndexEndIndexIndexUnitBit Incomplete
|
|
|
|
func (c BitposIndexEndIndexIndexUnitBit) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitposIndexEndIndexIndexUnitBit) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitposIndexEndIndexIndexUnitByte Incomplete
|
|
|
|
func (c BitposIndexEndIndexIndexUnitByte) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitposIndexEndIndexIndexUnitByte) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitposIndexStart Incomplete
|
|
|
|
func (c BitposIndexStart) End(end int64) BitposIndexEndIndexEnd {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(end, 10))
|
|
return (BitposIndexEndIndexEnd)(c)
|
|
}
|
|
|
|
func (c BitposIndexStart) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c BitposIndexStart) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type BitposKey Incomplete
|
|
|
|
func (c BitposKey) Bit(bit int64) BitposBit {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(bit, 10))
|
|
return (BitposBit)(c)
|
|
}
|
|
|
|
type Getbit Incomplete
|
|
|
|
func (b Builder) Getbit() (c Getbit) {
|
|
c = Getbit{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "GETBIT")
|
|
return c
|
|
}
|
|
|
|
func (c Getbit) Key(key string) GetbitKey {
|
|
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 (GetbitKey)(c)
|
|
}
|
|
|
|
type GetbitKey Incomplete
|
|
|
|
func (c GetbitKey) Offset(offset int64) GetbitOffset {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
|
|
return (GetbitOffset)(c)
|
|
}
|
|
|
|
type GetbitOffset Incomplete
|
|
|
|
func (c GetbitOffset) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c GetbitOffset) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Setbit Incomplete
|
|
|
|
func (b Builder) Setbit() (c Setbit) {
|
|
c = Setbit{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "SETBIT")
|
|
return c
|
|
}
|
|
|
|
func (c Setbit) Key(key string) SetbitKey {
|
|
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 (SetbitKey)(c)
|
|
}
|
|
|
|
type SetbitKey Incomplete
|
|
|
|
func (c SetbitKey) Offset(offset int64) SetbitOffset {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(offset, 10))
|
|
return (SetbitOffset)(c)
|
|
}
|
|
|
|
type SetbitOffset Incomplete
|
|
|
|
func (c SetbitOffset) Value(value int64) SetbitValue {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(value, 10))
|
|
return (SetbitValue)(c)
|
|
}
|
|
|
|
type SetbitValue Incomplete
|
|
|
|
func (c SetbitValue) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|