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>
543 lines
12 KiB
Go
543 lines
12 KiB
Go
// Code generated DO NOT EDIT
|
|
|
|
package cmds
|
|
|
|
import "strconv"
|
|
|
|
type CfAdd Incomplete
|
|
|
|
func (b Builder) CfAdd() (c CfAdd) {
|
|
c = CfAdd{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.ADD")
|
|
return c
|
|
}
|
|
|
|
func (c CfAdd) Key(key string) CfAddKey {
|
|
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 (CfAddKey)(c)
|
|
}
|
|
|
|
type CfAddItem Incomplete
|
|
|
|
func (c CfAddItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfAddKey Incomplete
|
|
|
|
func (c CfAddKey) Item(item string) CfAddItem {
|
|
c.cs.s = append(c.cs.s, item)
|
|
return (CfAddItem)(c)
|
|
}
|
|
|
|
type CfAddnx Incomplete
|
|
|
|
func (b Builder) CfAddnx() (c CfAddnx) {
|
|
c = CfAddnx{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.ADDNX")
|
|
return c
|
|
}
|
|
|
|
func (c CfAddnx) Key(key string) CfAddnxKey {
|
|
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 (CfAddnxKey)(c)
|
|
}
|
|
|
|
type CfAddnxItem Incomplete
|
|
|
|
func (c CfAddnxItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfAddnxKey Incomplete
|
|
|
|
func (c CfAddnxKey) Item(item string) CfAddnxItem {
|
|
c.cs.s = append(c.cs.s, item)
|
|
return (CfAddnxItem)(c)
|
|
}
|
|
|
|
type CfCount Incomplete
|
|
|
|
func (b Builder) CfCount() (c CfCount) {
|
|
c = CfCount{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "CF.COUNT")
|
|
return c
|
|
}
|
|
|
|
func (c CfCount) Key(key string) CfCountKey {
|
|
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 (CfCountKey)(c)
|
|
}
|
|
|
|
type CfCountItem Incomplete
|
|
|
|
func (c CfCountItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c CfCountItem) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfCountKey Incomplete
|
|
|
|
func (c CfCountKey) Item(item string) CfCountItem {
|
|
c.cs.s = append(c.cs.s, item)
|
|
return (CfCountItem)(c)
|
|
}
|
|
|
|
type CfDel Incomplete
|
|
|
|
func (b Builder) CfDel() (c CfDel) {
|
|
c = CfDel{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.DEL")
|
|
return c
|
|
}
|
|
|
|
func (c CfDel) Key(key string) CfDelKey {
|
|
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 (CfDelKey)(c)
|
|
}
|
|
|
|
type CfDelItem Incomplete
|
|
|
|
func (c CfDelItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfDelKey Incomplete
|
|
|
|
func (c CfDelKey) Item(item string) CfDelItem {
|
|
c.cs.s = append(c.cs.s, item)
|
|
return (CfDelItem)(c)
|
|
}
|
|
|
|
type CfExists Incomplete
|
|
|
|
func (b Builder) CfExists() (c CfExists) {
|
|
c = CfExists{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "CF.EXISTS")
|
|
return c
|
|
}
|
|
|
|
func (c CfExists) Key(key string) CfExistsKey {
|
|
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 (CfExistsKey)(c)
|
|
}
|
|
|
|
type CfExistsItem Incomplete
|
|
|
|
func (c CfExistsItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c CfExistsItem) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfExistsKey Incomplete
|
|
|
|
func (c CfExistsKey) Item(item string) CfExistsItem {
|
|
c.cs.s = append(c.cs.s, item)
|
|
return (CfExistsItem)(c)
|
|
}
|
|
|
|
type CfInfo Incomplete
|
|
|
|
func (b Builder) CfInfo() (c CfInfo) {
|
|
c = CfInfo{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "CF.INFO")
|
|
return c
|
|
}
|
|
|
|
func (c CfInfo) Key(key string) CfInfoKey {
|
|
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 (CfInfoKey)(c)
|
|
}
|
|
|
|
type CfInfoKey Incomplete
|
|
|
|
func (c CfInfoKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
func (c CfInfoKey) Cache() Cacheable {
|
|
c.cs.Build()
|
|
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfInsert Incomplete
|
|
|
|
func (b Builder) CfInsert() (c CfInsert) {
|
|
c = CfInsert{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.INSERT")
|
|
return c
|
|
}
|
|
|
|
func (c CfInsert) Key(key string) CfInsertKey {
|
|
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 (CfInsertKey)(c)
|
|
}
|
|
|
|
type CfInsertCapacity Incomplete
|
|
|
|
func (c CfInsertCapacity) Nocreate() CfInsertNocreate {
|
|
c.cs.s = append(c.cs.s, "NOCREATE")
|
|
return (CfInsertNocreate)(c)
|
|
}
|
|
|
|
func (c CfInsertCapacity) Items() CfInsertItems {
|
|
c.cs.s = append(c.cs.s, "ITEMS")
|
|
return (CfInsertItems)(c)
|
|
}
|
|
|
|
type CfInsertItem Incomplete
|
|
|
|
func (c CfInsertItem) Item(item ...string) CfInsertItem {
|
|
c.cs.s = append(c.cs.s, item...)
|
|
return c
|
|
}
|
|
|
|
func (c CfInsertItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfInsertItems Incomplete
|
|
|
|
func (c CfInsertItems) Item(item ...string) CfInsertItem {
|
|
c.cs.s = append(c.cs.s, item...)
|
|
return (CfInsertItem)(c)
|
|
}
|
|
|
|
type CfInsertKey Incomplete
|
|
|
|
func (c CfInsertKey) Capacity(capacity int64) CfInsertCapacity {
|
|
c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
|
|
return (CfInsertCapacity)(c)
|
|
}
|
|
|
|
func (c CfInsertKey) Nocreate() CfInsertNocreate {
|
|
c.cs.s = append(c.cs.s, "NOCREATE")
|
|
return (CfInsertNocreate)(c)
|
|
}
|
|
|
|
func (c CfInsertKey) Items() CfInsertItems {
|
|
c.cs.s = append(c.cs.s, "ITEMS")
|
|
return (CfInsertItems)(c)
|
|
}
|
|
|
|
type CfInsertNocreate Incomplete
|
|
|
|
func (c CfInsertNocreate) Items() CfInsertItems {
|
|
c.cs.s = append(c.cs.s, "ITEMS")
|
|
return (CfInsertItems)(c)
|
|
}
|
|
|
|
type CfInsertnx Incomplete
|
|
|
|
func (b Builder) CfInsertnx() (c CfInsertnx) {
|
|
c = CfInsertnx{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.INSERTNX")
|
|
return c
|
|
}
|
|
|
|
func (c CfInsertnx) Key(key string) CfInsertnxKey {
|
|
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 (CfInsertnxKey)(c)
|
|
}
|
|
|
|
type CfInsertnxCapacity Incomplete
|
|
|
|
func (c CfInsertnxCapacity) Nocreate() CfInsertnxNocreate {
|
|
c.cs.s = append(c.cs.s, "NOCREATE")
|
|
return (CfInsertnxNocreate)(c)
|
|
}
|
|
|
|
func (c CfInsertnxCapacity) Items() CfInsertnxItems {
|
|
c.cs.s = append(c.cs.s, "ITEMS")
|
|
return (CfInsertnxItems)(c)
|
|
}
|
|
|
|
type CfInsertnxItem Incomplete
|
|
|
|
func (c CfInsertnxItem) Item(item ...string) CfInsertnxItem {
|
|
c.cs.s = append(c.cs.s, item...)
|
|
return c
|
|
}
|
|
|
|
func (c CfInsertnxItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfInsertnxItems Incomplete
|
|
|
|
func (c CfInsertnxItems) Item(item ...string) CfInsertnxItem {
|
|
c.cs.s = append(c.cs.s, item...)
|
|
return (CfInsertnxItem)(c)
|
|
}
|
|
|
|
type CfInsertnxKey Incomplete
|
|
|
|
func (c CfInsertnxKey) Capacity(capacity int64) CfInsertnxCapacity {
|
|
c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
|
|
return (CfInsertnxCapacity)(c)
|
|
}
|
|
|
|
func (c CfInsertnxKey) Nocreate() CfInsertnxNocreate {
|
|
c.cs.s = append(c.cs.s, "NOCREATE")
|
|
return (CfInsertnxNocreate)(c)
|
|
}
|
|
|
|
func (c CfInsertnxKey) Items() CfInsertnxItems {
|
|
c.cs.s = append(c.cs.s, "ITEMS")
|
|
return (CfInsertnxItems)(c)
|
|
}
|
|
|
|
type CfInsertnxNocreate Incomplete
|
|
|
|
func (c CfInsertnxNocreate) Items() CfInsertnxItems {
|
|
c.cs.s = append(c.cs.s, "ITEMS")
|
|
return (CfInsertnxItems)(c)
|
|
}
|
|
|
|
type CfLoadchunk Incomplete
|
|
|
|
func (b Builder) CfLoadchunk() (c CfLoadchunk) {
|
|
c = CfLoadchunk{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.LOADCHUNK")
|
|
return c
|
|
}
|
|
|
|
func (c CfLoadchunk) Key(key string) CfLoadchunkKey {
|
|
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 (CfLoadchunkKey)(c)
|
|
}
|
|
|
|
type CfLoadchunkData Incomplete
|
|
|
|
func (c CfLoadchunkData) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfLoadchunkIterator Incomplete
|
|
|
|
func (c CfLoadchunkIterator) Data(data string) CfLoadchunkData {
|
|
c.cs.s = append(c.cs.s, data)
|
|
return (CfLoadchunkData)(c)
|
|
}
|
|
|
|
type CfLoadchunkKey Incomplete
|
|
|
|
func (c CfLoadchunkKey) Iterator(iterator int64) CfLoadchunkIterator {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
|
|
return (CfLoadchunkIterator)(c)
|
|
}
|
|
|
|
type CfMexists Incomplete
|
|
|
|
func (b Builder) CfMexists() (c CfMexists) {
|
|
c = CfMexists{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.MEXISTS")
|
|
return c
|
|
}
|
|
|
|
func (c CfMexists) Key(key string) CfMexistsKey {
|
|
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 (CfMexistsKey)(c)
|
|
}
|
|
|
|
type CfMexistsItem Incomplete
|
|
|
|
func (c CfMexistsItem) Item(item ...string) CfMexistsItem {
|
|
c.cs.s = append(c.cs.s, item...)
|
|
return c
|
|
}
|
|
|
|
func (c CfMexistsItem) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfMexistsKey Incomplete
|
|
|
|
func (c CfMexistsKey) Item(item ...string) CfMexistsItem {
|
|
c.cs.s = append(c.cs.s, item...)
|
|
return (CfMexistsItem)(c)
|
|
}
|
|
|
|
type CfReserve Incomplete
|
|
|
|
func (b Builder) CfReserve() (c CfReserve) {
|
|
c = CfReserve{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "CF.RESERVE")
|
|
return c
|
|
}
|
|
|
|
func (c CfReserve) Key(key string) CfReserveKey {
|
|
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 (CfReserveKey)(c)
|
|
}
|
|
|
|
type CfReserveBucketsize Incomplete
|
|
|
|
func (c CfReserveBucketsize) Maxiterations(maxiterations int64) CfReserveMaxiterations {
|
|
c.cs.s = append(c.cs.s, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
|
|
return (CfReserveMaxiterations)(c)
|
|
}
|
|
|
|
func (c CfReserveBucketsize) Expansion(expansion int64) CfReserveExpansion {
|
|
c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
|
|
return (CfReserveExpansion)(c)
|
|
}
|
|
|
|
func (c CfReserveBucketsize) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfReserveCapacity Incomplete
|
|
|
|
func (c CfReserveCapacity) Bucketsize(bucketsize int64) CfReserveBucketsize {
|
|
c.cs.s = append(c.cs.s, "BUCKETSIZE", strconv.FormatInt(bucketsize, 10))
|
|
return (CfReserveBucketsize)(c)
|
|
}
|
|
|
|
func (c CfReserveCapacity) Maxiterations(maxiterations int64) CfReserveMaxiterations {
|
|
c.cs.s = append(c.cs.s, "MAXITERATIONS", strconv.FormatInt(maxiterations, 10))
|
|
return (CfReserveMaxiterations)(c)
|
|
}
|
|
|
|
func (c CfReserveCapacity) Expansion(expansion int64) CfReserveExpansion {
|
|
c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
|
|
return (CfReserveExpansion)(c)
|
|
}
|
|
|
|
func (c CfReserveCapacity) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfReserveExpansion Incomplete
|
|
|
|
func (c CfReserveExpansion) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfReserveKey Incomplete
|
|
|
|
func (c CfReserveKey) Capacity(capacity int64) CfReserveCapacity {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(capacity, 10))
|
|
return (CfReserveCapacity)(c)
|
|
}
|
|
|
|
type CfReserveMaxiterations Incomplete
|
|
|
|
func (c CfReserveMaxiterations) Expansion(expansion int64) CfReserveExpansion {
|
|
c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
|
|
return (CfReserveExpansion)(c)
|
|
}
|
|
|
|
func (c CfReserveMaxiterations) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfScandump Incomplete
|
|
|
|
func (b Builder) CfScandump() (c CfScandump) {
|
|
c = CfScandump{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "CF.SCANDUMP")
|
|
return c
|
|
}
|
|
|
|
func (c CfScandump) Key(key string) CfScandumpKey {
|
|
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 (CfScandumpKey)(c)
|
|
}
|
|
|
|
type CfScandumpIterator Incomplete
|
|
|
|
func (c CfScandumpIterator) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type CfScandumpKey Incomplete
|
|
|
|
func (c CfScandumpKey) Iterator(iterator int64) CfScandumpIterator {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
|
|
return (CfScandumpIterator)(c)
|
|
}
|