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>
1746 lines
39 KiB
Go
1746 lines
39 KiB
Go
// Code generated DO NOT EDIT
|
|
|
|
package cmds
|
|
|
|
import "strconv"
|
|
|
|
type Xack Incomplete
|
|
|
|
func (b Builder) Xack() (c Xack) {
|
|
c = Xack{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XACK")
|
|
return c
|
|
}
|
|
|
|
func (c Xack) Key(key string) XackKey {
|
|
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 (XackKey)(c)
|
|
}
|
|
|
|
type XackGroup Incomplete
|
|
|
|
func (c XackGroup) Id(id ...string) XackId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XackId)(c)
|
|
}
|
|
|
|
type XackId Incomplete
|
|
|
|
func (c XackId) Id(id ...string) XackId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XackId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XackKey Incomplete
|
|
|
|
func (c XackKey) Group(group string) XackGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XackGroup)(c)
|
|
}
|
|
|
|
type Xackdel Incomplete
|
|
|
|
func (b Builder) Xackdel() (c Xackdel) {
|
|
c = Xackdel{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XACKDEL")
|
|
return c
|
|
}
|
|
|
|
func (c Xackdel) Key(key string) XackdelKey {
|
|
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 (XackdelKey)(c)
|
|
}
|
|
|
|
type XackdelActionAcked Incomplete
|
|
|
|
func (c XackdelActionAcked) Ids() XackdelIdsBlockIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XackdelIdsBlockIds)(c)
|
|
}
|
|
|
|
type XackdelActionDelref Incomplete
|
|
|
|
func (c XackdelActionDelref) Ids() XackdelIdsBlockIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XackdelIdsBlockIds)(c)
|
|
}
|
|
|
|
type XackdelActionKeepref Incomplete
|
|
|
|
func (c XackdelActionKeepref) Ids() XackdelIdsBlockIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XackdelIdsBlockIds)(c)
|
|
}
|
|
|
|
type XackdelGroup Incomplete
|
|
|
|
func (c XackdelGroup) Keepref() XackdelActionKeepref {
|
|
c.cs.s = append(c.cs.s, "KEEPREF")
|
|
return (XackdelActionKeepref)(c)
|
|
}
|
|
|
|
func (c XackdelGroup) Delref() XackdelActionDelref {
|
|
c.cs.s = append(c.cs.s, "DELREF")
|
|
return (XackdelActionDelref)(c)
|
|
}
|
|
|
|
func (c XackdelGroup) Acked() XackdelActionAcked {
|
|
c.cs.s = append(c.cs.s, "ACKED")
|
|
return (XackdelActionAcked)(c)
|
|
}
|
|
|
|
func (c XackdelGroup) Ids() XackdelIdsBlockIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XackdelIdsBlockIds)(c)
|
|
}
|
|
|
|
type XackdelIdsBlockId Incomplete
|
|
|
|
func (c XackdelIdsBlockId) Id(id ...string) XackdelIdsBlockId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XackdelIdsBlockId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XackdelIdsBlockIds Incomplete
|
|
|
|
func (c XackdelIdsBlockIds) Numids(numids int64) XackdelIdsBlockNumids {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(numids, 10))
|
|
return (XackdelIdsBlockNumids)(c)
|
|
}
|
|
|
|
type XackdelIdsBlockNumids Incomplete
|
|
|
|
func (c XackdelIdsBlockNumids) Id(id ...string) XackdelIdsBlockId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XackdelIdsBlockId)(c)
|
|
}
|
|
|
|
type XackdelKey Incomplete
|
|
|
|
func (c XackdelKey) Group(group string) XackdelGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XackdelGroup)(c)
|
|
}
|
|
|
|
type Xadd Incomplete
|
|
|
|
func (b Builder) Xadd() (c Xadd) {
|
|
c = Xadd{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XADD")
|
|
return c
|
|
}
|
|
|
|
func (c Xadd) Key(key string) XaddKey {
|
|
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 (XaddKey)(c)
|
|
}
|
|
|
|
type XaddFieldValue Incomplete
|
|
|
|
func (c XaddFieldValue) FieldValue(field string, value string) XaddFieldValue {
|
|
c.cs.s = append(c.cs.s, field, value)
|
|
return c
|
|
}
|
|
|
|
func (c XaddFieldValue) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XaddId Incomplete
|
|
|
|
func (c XaddId) FieldValue() XaddFieldValue {
|
|
return (XaddFieldValue)(c)
|
|
}
|
|
|
|
type XaddKey Incomplete
|
|
|
|
func (c XaddKey) Nomkstream() XaddNomkstream {
|
|
c.cs.s = append(c.cs.s, "NOMKSTREAM")
|
|
return (XaddNomkstream)(c)
|
|
}
|
|
|
|
func (c XaddKey) Maxlen() XaddTrimStrategyMaxlen {
|
|
c.cs.s = append(c.cs.s, "MAXLEN")
|
|
return (XaddTrimStrategyMaxlen)(c)
|
|
}
|
|
|
|
func (c XaddKey) Minid() XaddTrimStrategyMinid {
|
|
c.cs.s = append(c.cs.s, "MINID")
|
|
return (XaddTrimStrategyMinid)(c)
|
|
}
|
|
|
|
func (c XaddKey) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type XaddNomkstream Incomplete
|
|
|
|
func (c XaddNomkstream) Maxlen() XaddTrimStrategyMaxlen {
|
|
c.cs.s = append(c.cs.s, "MAXLEN")
|
|
return (XaddTrimStrategyMaxlen)(c)
|
|
}
|
|
|
|
func (c XaddNomkstream) Minid() XaddTrimStrategyMinid {
|
|
c.cs.s = append(c.cs.s, "MINID")
|
|
return (XaddTrimStrategyMinid)(c)
|
|
}
|
|
|
|
func (c XaddNomkstream) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type XaddTrimLimit Incomplete
|
|
|
|
func (c XaddTrimLimit) Keepref() XaddTrimReferenceKeepref {
|
|
c.cs.s = append(c.cs.s, "KEEPREF")
|
|
return (XaddTrimReferenceKeepref)(c)
|
|
}
|
|
|
|
func (c XaddTrimLimit) Delref() XaddTrimReferenceDelref {
|
|
c.cs.s = append(c.cs.s, "DELREF")
|
|
return (XaddTrimReferenceDelref)(c)
|
|
}
|
|
|
|
func (c XaddTrimLimit) Acked() XaddTrimReferenceAcked {
|
|
c.cs.s = append(c.cs.s, "ACKED")
|
|
return (XaddTrimReferenceAcked)(c)
|
|
}
|
|
|
|
func (c XaddTrimLimit) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type XaddTrimOperatorAlmost Incomplete
|
|
|
|
func (c XaddTrimOperatorAlmost) Threshold(threshold string) XaddTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XaddTrimThreshold)(c)
|
|
}
|
|
|
|
type XaddTrimOperatorExact Incomplete
|
|
|
|
func (c XaddTrimOperatorExact) Threshold(threshold string) XaddTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XaddTrimThreshold)(c)
|
|
}
|
|
|
|
type XaddTrimReferenceAcked Incomplete
|
|
|
|
func (c XaddTrimReferenceAcked) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type XaddTrimReferenceDelref Incomplete
|
|
|
|
func (c XaddTrimReferenceDelref) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type XaddTrimReferenceKeepref Incomplete
|
|
|
|
func (c XaddTrimReferenceKeepref) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type XaddTrimStrategyMaxlen Incomplete
|
|
|
|
func (c XaddTrimStrategyMaxlen) Exact() XaddTrimOperatorExact {
|
|
c.cs.s = append(c.cs.s, "=")
|
|
return (XaddTrimOperatorExact)(c)
|
|
}
|
|
|
|
func (c XaddTrimStrategyMaxlen) Almost() XaddTrimOperatorAlmost {
|
|
c.cs.s = append(c.cs.s, "~")
|
|
return (XaddTrimOperatorAlmost)(c)
|
|
}
|
|
|
|
func (c XaddTrimStrategyMaxlen) Threshold(threshold string) XaddTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XaddTrimThreshold)(c)
|
|
}
|
|
|
|
type XaddTrimStrategyMinid Incomplete
|
|
|
|
func (c XaddTrimStrategyMinid) Exact() XaddTrimOperatorExact {
|
|
c.cs.s = append(c.cs.s, "=")
|
|
return (XaddTrimOperatorExact)(c)
|
|
}
|
|
|
|
func (c XaddTrimStrategyMinid) Almost() XaddTrimOperatorAlmost {
|
|
c.cs.s = append(c.cs.s, "~")
|
|
return (XaddTrimOperatorAlmost)(c)
|
|
}
|
|
|
|
func (c XaddTrimStrategyMinid) Threshold(threshold string) XaddTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XaddTrimThreshold)(c)
|
|
}
|
|
|
|
type XaddTrimThreshold Incomplete
|
|
|
|
func (c XaddTrimThreshold) Limit(count int64) XaddTrimLimit {
|
|
c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
|
|
return (XaddTrimLimit)(c)
|
|
}
|
|
|
|
func (c XaddTrimThreshold) Keepref() XaddTrimReferenceKeepref {
|
|
c.cs.s = append(c.cs.s, "KEEPREF")
|
|
return (XaddTrimReferenceKeepref)(c)
|
|
}
|
|
|
|
func (c XaddTrimThreshold) Delref() XaddTrimReferenceDelref {
|
|
c.cs.s = append(c.cs.s, "DELREF")
|
|
return (XaddTrimReferenceDelref)(c)
|
|
}
|
|
|
|
func (c XaddTrimThreshold) Acked() XaddTrimReferenceAcked {
|
|
c.cs.s = append(c.cs.s, "ACKED")
|
|
return (XaddTrimReferenceAcked)(c)
|
|
}
|
|
|
|
func (c XaddTrimThreshold) Id(id string) XaddId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XaddId)(c)
|
|
}
|
|
|
|
type Xautoclaim Incomplete
|
|
|
|
func (b Builder) Xautoclaim() (c Xautoclaim) {
|
|
c = Xautoclaim{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XAUTOCLAIM")
|
|
return c
|
|
}
|
|
|
|
func (c Xautoclaim) Key(key string) XautoclaimKey {
|
|
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 (XautoclaimKey)(c)
|
|
}
|
|
|
|
type XautoclaimConsumer Incomplete
|
|
|
|
func (c XautoclaimConsumer) MinIdleTime(minIdleTime string) XautoclaimMinIdleTime {
|
|
c.cs.s = append(c.cs.s, minIdleTime)
|
|
return (XautoclaimMinIdleTime)(c)
|
|
}
|
|
|
|
type XautoclaimCount Incomplete
|
|
|
|
func (c XautoclaimCount) Justid() XautoclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XautoclaimJustid)(c)
|
|
}
|
|
|
|
func (c XautoclaimCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XautoclaimGroup Incomplete
|
|
|
|
func (c XautoclaimGroup) Consumer(consumer string) XautoclaimConsumer {
|
|
c.cs.s = append(c.cs.s, consumer)
|
|
return (XautoclaimConsumer)(c)
|
|
}
|
|
|
|
type XautoclaimJustid Incomplete
|
|
|
|
func (c XautoclaimJustid) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XautoclaimKey Incomplete
|
|
|
|
func (c XautoclaimKey) Group(group string) XautoclaimGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XautoclaimGroup)(c)
|
|
}
|
|
|
|
type XautoclaimMinIdleTime Incomplete
|
|
|
|
func (c XautoclaimMinIdleTime) Start(start string) XautoclaimStart {
|
|
c.cs.s = append(c.cs.s, start)
|
|
return (XautoclaimStart)(c)
|
|
}
|
|
|
|
type XautoclaimStart Incomplete
|
|
|
|
func (c XautoclaimStart) Count(count int64) XautoclaimCount {
|
|
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
|
|
return (XautoclaimCount)(c)
|
|
}
|
|
|
|
func (c XautoclaimStart) Justid() XautoclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XautoclaimJustid)(c)
|
|
}
|
|
|
|
func (c XautoclaimStart) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Xclaim Incomplete
|
|
|
|
func (b Builder) Xclaim() (c Xclaim) {
|
|
c = Xclaim{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XCLAIM")
|
|
return c
|
|
}
|
|
|
|
func (c Xclaim) Key(key string) XclaimKey {
|
|
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 (XclaimKey)(c)
|
|
}
|
|
|
|
type XclaimConsumer Incomplete
|
|
|
|
func (c XclaimConsumer) MinIdleTime(minIdleTime string) XclaimMinIdleTime {
|
|
c.cs.s = append(c.cs.s, minIdleTime)
|
|
return (XclaimMinIdleTime)(c)
|
|
}
|
|
|
|
type XclaimForce Incomplete
|
|
|
|
func (c XclaimForce) Justid() XclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XclaimJustid)(c)
|
|
}
|
|
|
|
func (c XclaimForce) Lastid() XclaimLastid {
|
|
c.cs.s = append(c.cs.s, "LASTID")
|
|
return (XclaimLastid)(c)
|
|
}
|
|
|
|
func (c XclaimForce) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XclaimGroup Incomplete
|
|
|
|
func (c XclaimGroup) Consumer(consumer string) XclaimConsumer {
|
|
c.cs.s = append(c.cs.s, consumer)
|
|
return (XclaimConsumer)(c)
|
|
}
|
|
|
|
type XclaimId Incomplete
|
|
|
|
func (c XclaimId) Id(id ...string) XclaimId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XclaimId) Idle(ms int64) XclaimIdle {
|
|
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(ms, 10))
|
|
return (XclaimIdle)(c)
|
|
}
|
|
|
|
func (c XclaimId) Time(msUnixTime int64) XclaimTime {
|
|
c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
|
|
return (XclaimTime)(c)
|
|
}
|
|
|
|
func (c XclaimId) Retrycount(count int64) XclaimRetrycount {
|
|
c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
|
|
return (XclaimRetrycount)(c)
|
|
}
|
|
|
|
func (c XclaimId) Force() XclaimForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (XclaimForce)(c)
|
|
}
|
|
|
|
func (c XclaimId) Justid() XclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XclaimJustid)(c)
|
|
}
|
|
|
|
func (c XclaimId) Lastid() XclaimLastid {
|
|
c.cs.s = append(c.cs.s, "LASTID")
|
|
return (XclaimLastid)(c)
|
|
}
|
|
|
|
func (c XclaimId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XclaimIdle Incomplete
|
|
|
|
func (c XclaimIdle) Time(msUnixTime int64) XclaimTime {
|
|
c.cs.s = append(c.cs.s, "TIME", strconv.FormatInt(msUnixTime, 10))
|
|
return (XclaimTime)(c)
|
|
}
|
|
|
|
func (c XclaimIdle) Retrycount(count int64) XclaimRetrycount {
|
|
c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
|
|
return (XclaimRetrycount)(c)
|
|
}
|
|
|
|
func (c XclaimIdle) Force() XclaimForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (XclaimForce)(c)
|
|
}
|
|
|
|
func (c XclaimIdle) Justid() XclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XclaimJustid)(c)
|
|
}
|
|
|
|
func (c XclaimIdle) Lastid() XclaimLastid {
|
|
c.cs.s = append(c.cs.s, "LASTID")
|
|
return (XclaimLastid)(c)
|
|
}
|
|
|
|
func (c XclaimIdle) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XclaimJustid Incomplete
|
|
|
|
func (c XclaimJustid) Lastid() XclaimLastid {
|
|
c.cs.s = append(c.cs.s, "LASTID")
|
|
return (XclaimLastid)(c)
|
|
}
|
|
|
|
func (c XclaimJustid) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XclaimKey Incomplete
|
|
|
|
func (c XclaimKey) Group(group string) XclaimGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XclaimGroup)(c)
|
|
}
|
|
|
|
type XclaimLastid Incomplete
|
|
|
|
func (c XclaimLastid) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XclaimMinIdleTime Incomplete
|
|
|
|
func (c XclaimMinIdleTime) Id(id ...string) XclaimId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XclaimId)(c)
|
|
}
|
|
|
|
type XclaimRetrycount Incomplete
|
|
|
|
func (c XclaimRetrycount) Force() XclaimForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (XclaimForce)(c)
|
|
}
|
|
|
|
func (c XclaimRetrycount) Justid() XclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XclaimJustid)(c)
|
|
}
|
|
|
|
func (c XclaimRetrycount) Lastid() XclaimLastid {
|
|
c.cs.s = append(c.cs.s, "LASTID")
|
|
return (XclaimLastid)(c)
|
|
}
|
|
|
|
func (c XclaimRetrycount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XclaimTime Incomplete
|
|
|
|
func (c XclaimTime) Retrycount(count int64) XclaimRetrycount {
|
|
c.cs.s = append(c.cs.s, "RETRYCOUNT", strconv.FormatInt(count, 10))
|
|
return (XclaimRetrycount)(c)
|
|
}
|
|
|
|
func (c XclaimTime) Force() XclaimForce {
|
|
c.cs.s = append(c.cs.s, "FORCE")
|
|
return (XclaimForce)(c)
|
|
}
|
|
|
|
func (c XclaimTime) Justid() XclaimJustid {
|
|
c.cs.s = append(c.cs.s, "JUSTID")
|
|
return (XclaimJustid)(c)
|
|
}
|
|
|
|
func (c XclaimTime) Lastid() XclaimLastid {
|
|
c.cs.s = append(c.cs.s, "LASTID")
|
|
return (XclaimLastid)(c)
|
|
}
|
|
|
|
func (c XclaimTime) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Xdel Incomplete
|
|
|
|
func (b Builder) Xdel() (c Xdel) {
|
|
c = Xdel{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XDEL")
|
|
return c
|
|
}
|
|
|
|
func (c Xdel) Key(key string) XdelKey {
|
|
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 (XdelKey)(c)
|
|
}
|
|
|
|
type XdelId Incomplete
|
|
|
|
func (c XdelId) Id(id ...string) XdelId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XdelId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XdelKey Incomplete
|
|
|
|
func (c XdelKey) Id(id ...string) XdelId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XdelId)(c)
|
|
}
|
|
|
|
type Xdelex Incomplete
|
|
|
|
func (b Builder) Xdelex() (c Xdelex) {
|
|
c = Xdelex{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XDELEX")
|
|
return c
|
|
}
|
|
|
|
func (c Xdelex) Key(key string) XdelexKey {
|
|
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 (XdelexKey)(c)
|
|
}
|
|
|
|
type XdelexConditionAcked Incomplete
|
|
|
|
func (c XdelexConditionAcked) Ids() XdelexIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XdelexIds)(c)
|
|
}
|
|
|
|
type XdelexConditionDelref Incomplete
|
|
|
|
func (c XdelexConditionDelref) Ids() XdelexIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XdelexIds)(c)
|
|
}
|
|
|
|
type XdelexConditionKeepref Incomplete
|
|
|
|
func (c XdelexConditionKeepref) Ids() XdelexIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XdelexIds)(c)
|
|
}
|
|
|
|
type XdelexId Incomplete
|
|
|
|
func (c XdelexId) Id(id ...string) XdelexId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XdelexId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XdelexIds Incomplete
|
|
|
|
func (c XdelexIds) Numids(numids int64) XdelexNumids {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(numids, 10))
|
|
return (XdelexNumids)(c)
|
|
}
|
|
|
|
type XdelexKey Incomplete
|
|
|
|
func (c XdelexKey) Keepref() XdelexConditionKeepref {
|
|
c.cs.s = append(c.cs.s, "KEEPREF")
|
|
return (XdelexConditionKeepref)(c)
|
|
}
|
|
|
|
func (c XdelexKey) Delref() XdelexConditionDelref {
|
|
c.cs.s = append(c.cs.s, "DELREF")
|
|
return (XdelexConditionDelref)(c)
|
|
}
|
|
|
|
func (c XdelexKey) Acked() XdelexConditionAcked {
|
|
c.cs.s = append(c.cs.s, "ACKED")
|
|
return (XdelexConditionAcked)(c)
|
|
}
|
|
|
|
func (c XdelexKey) Ids() XdelexIds {
|
|
c.cs.s = append(c.cs.s, "IDS")
|
|
return (XdelexIds)(c)
|
|
}
|
|
|
|
type XdelexNumids Incomplete
|
|
|
|
func (c XdelexNumids) Id(id ...string) XdelexId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XdelexId)(c)
|
|
}
|
|
|
|
type XgroupCreate Incomplete
|
|
|
|
func (b Builder) XgroupCreate() (c XgroupCreate) {
|
|
c = XgroupCreate{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XGROUP", "CREATE")
|
|
return c
|
|
}
|
|
|
|
func (c XgroupCreate) Key(key string) XgroupCreateKey {
|
|
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 (XgroupCreateKey)(c)
|
|
}
|
|
|
|
type XgroupCreateEntriesread Incomplete
|
|
|
|
func (c XgroupCreateEntriesread) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupCreateGroup Incomplete
|
|
|
|
func (c XgroupCreateGroup) Id(id string) XgroupCreateId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XgroupCreateId)(c)
|
|
}
|
|
|
|
type XgroupCreateId Incomplete
|
|
|
|
func (c XgroupCreateId) Mkstream() XgroupCreateMkstream {
|
|
c.cs.s = append(c.cs.s, "MKSTREAM")
|
|
return (XgroupCreateMkstream)(c)
|
|
}
|
|
|
|
func (c XgroupCreateId) Entriesread(entriesRead int64) XgroupCreateEntriesread {
|
|
c.cs.s = append(c.cs.s, "ENTRIESREAD", strconv.FormatInt(entriesRead, 10))
|
|
return (XgroupCreateEntriesread)(c)
|
|
}
|
|
|
|
func (c XgroupCreateId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupCreateKey Incomplete
|
|
|
|
func (c XgroupCreateKey) Group(group string) XgroupCreateGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XgroupCreateGroup)(c)
|
|
}
|
|
|
|
type XgroupCreateMkstream Incomplete
|
|
|
|
func (c XgroupCreateMkstream) Entriesread(entriesRead int64) XgroupCreateEntriesread {
|
|
c.cs.s = append(c.cs.s, "ENTRIESREAD", strconv.FormatInt(entriesRead, 10))
|
|
return (XgroupCreateEntriesread)(c)
|
|
}
|
|
|
|
func (c XgroupCreateMkstream) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupCreateconsumer Incomplete
|
|
|
|
func (b Builder) XgroupCreateconsumer() (c XgroupCreateconsumer) {
|
|
c = XgroupCreateconsumer{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XGROUP", "CREATECONSUMER")
|
|
return c
|
|
}
|
|
|
|
func (c XgroupCreateconsumer) Key(key string) XgroupCreateconsumerKey {
|
|
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 (XgroupCreateconsumerKey)(c)
|
|
}
|
|
|
|
type XgroupCreateconsumerConsumer Incomplete
|
|
|
|
func (c XgroupCreateconsumerConsumer) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupCreateconsumerGroup Incomplete
|
|
|
|
func (c XgroupCreateconsumerGroup) Consumer(consumer string) XgroupCreateconsumerConsumer {
|
|
c.cs.s = append(c.cs.s, consumer)
|
|
return (XgroupCreateconsumerConsumer)(c)
|
|
}
|
|
|
|
type XgroupCreateconsumerKey Incomplete
|
|
|
|
func (c XgroupCreateconsumerKey) Group(group string) XgroupCreateconsumerGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XgroupCreateconsumerGroup)(c)
|
|
}
|
|
|
|
type XgroupDelconsumer Incomplete
|
|
|
|
func (b Builder) XgroupDelconsumer() (c XgroupDelconsumer) {
|
|
c = XgroupDelconsumer{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XGROUP", "DELCONSUMER")
|
|
return c
|
|
}
|
|
|
|
func (c XgroupDelconsumer) Key(key string) XgroupDelconsumerKey {
|
|
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 (XgroupDelconsumerKey)(c)
|
|
}
|
|
|
|
type XgroupDelconsumerConsumername Incomplete
|
|
|
|
func (c XgroupDelconsumerConsumername) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupDelconsumerGroup Incomplete
|
|
|
|
func (c XgroupDelconsumerGroup) Consumername(consumername string) XgroupDelconsumerConsumername {
|
|
c.cs.s = append(c.cs.s, consumername)
|
|
return (XgroupDelconsumerConsumername)(c)
|
|
}
|
|
|
|
type XgroupDelconsumerKey Incomplete
|
|
|
|
func (c XgroupDelconsumerKey) Group(group string) XgroupDelconsumerGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XgroupDelconsumerGroup)(c)
|
|
}
|
|
|
|
type XgroupDestroy Incomplete
|
|
|
|
func (b Builder) XgroupDestroy() (c XgroupDestroy) {
|
|
c = XgroupDestroy{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XGROUP", "DESTROY")
|
|
return c
|
|
}
|
|
|
|
func (c XgroupDestroy) Key(key string) XgroupDestroyKey {
|
|
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 (XgroupDestroyKey)(c)
|
|
}
|
|
|
|
type XgroupDestroyGroup Incomplete
|
|
|
|
func (c XgroupDestroyGroup) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupDestroyKey Incomplete
|
|
|
|
func (c XgroupDestroyKey) Group(group string) XgroupDestroyGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XgroupDestroyGroup)(c)
|
|
}
|
|
|
|
type XgroupHelp Incomplete
|
|
|
|
func (b Builder) XgroupHelp() (c XgroupHelp) {
|
|
c = XgroupHelp{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XGROUP", "HELP")
|
|
return c
|
|
}
|
|
|
|
func (c XgroupHelp) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupSetid Incomplete
|
|
|
|
func (b Builder) XgroupSetid() (c XgroupSetid) {
|
|
c = XgroupSetid{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XGROUP", "SETID")
|
|
return c
|
|
}
|
|
|
|
func (c XgroupSetid) Key(key string) XgroupSetidKey {
|
|
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 (XgroupSetidKey)(c)
|
|
}
|
|
|
|
type XgroupSetidEntriesread Incomplete
|
|
|
|
func (c XgroupSetidEntriesread) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupSetidGroup Incomplete
|
|
|
|
func (c XgroupSetidGroup) Id(id string) XgroupSetidId {
|
|
c.cs.s = append(c.cs.s, id)
|
|
return (XgroupSetidId)(c)
|
|
}
|
|
|
|
type XgroupSetidId Incomplete
|
|
|
|
func (c XgroupSetidId) Entriesread(entriesRead int64) XgroupSetidEntriesread {
|
|
c.cs.s = append(c.cs.s, "ENTRIESREAD", strconv.FormatInt(entriesRead, 10))
|
|
return (XgroupSetidEntriesread)(c)
|
|
}
|
|
|
|
func (c XgroupSetidId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XgroupSetidKey Incomplete
|
|
|
|
func (c XgroupSetidKey) Group(group string) XgroupSetidGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XgroupSetidGroup)(c)
|
|
}
|
|
|
|
type XinfoConsumers Incomplete
|
|
|
|
func (b Builder) XinfoConsumers() (c XinfoConsumers) {
|
|
c = XinfoConsumers{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XINFO", "CONSUMERS")
|
|
return c
|
|
}
|
|
|
|
func (c XinfoConsumers) Key(key string) XinfoConsumersKey {
|
|
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 (XinfoConsumersKey)(c)
|
|
}
|
|
|
|
type XinfoConsumersGroup Incomplete
|
|
|
|
func (c XinfoConsumersGroup) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XinfoConsumersKey Incomplete
|
|
|
|
func (c XinfoConsumersKey) Group(group string) XinfoConsumersGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XinfoConsumersGroup)(c)
|
|
}
|
|
|
|
type XinfoGroups Incomplete
|
|
|
|
func (b Builder) XinfoGroups() (c XinfoGroups) {
|
|
c = XinfoGroups{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XINFO", "GROUPS")
|
|
return c
|
|
}
|
|
|
|
func (c XinfoGroups) Key(key string) XinfoGroupsKey {
|
|
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 (XinfoGroupsKey)(c)
|
|
}
|
|
|
|
type XinfoGroupsKey Incomplete
|
|
|
|
func (c XinfoGroupsKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XinfoHelp Incomplete
|
|
|
|
func (b Builder) XinfoHelp() (c XinfoHelp) {
|
|
c = XinfoHelp{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XINFO", "HELP")
|
|
return c
|
|
}
|
|
|
|
func (c XinfoHelp) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XinfoStream Incomplete
|
|
|
|
func (b Builder) XinfoStream() (c XinfoStream) {
|
|
c = XinfoStream{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XINFO", "STREAM")
|
|
return c
|
|
}
|
|
|
|
func (c XinfoStream) Key(key string) XinfoStreamKey {
|
|
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 (XinfoStreamKey)(c)
|
|
}
|
|
|
|
type XinfoStreamFullCount Incomplete
|
|
|
|
func (c XinfoStreamFullCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XinfoStreamFullFull Incomplete
|
|
|
|
func (c XinfoStreamFullFull) Count(count int64) XinfoStreamFullCount {
|
|
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
|
|
return (XinfoStreamFullCount)(c)
|
|
}
|
|
|
|
func (c XinfoStreamFullFull) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XinfoStreamKey Incomplete
|
|
|
|
func (c XinfoStreamKey) Full() XinfoStreamFullFull {
|
|
c.cs.s = append(c.cs.s, "FULL")
|
|
return (XinfoStreamFullFull)(c)
|
|
}
|
|
|
|
func (c XinfoStreamKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Xlen Incomplete
|
|
|
|
func (b Builder) Xlen() (c Xlen) {
|
|
c = Xlen{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XLEN")
|
|
return c
|
|
}
|
|
|
|
func (c Xlen) Key(key string) XlenKey {
|
|
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 (XlenKey)(c)
|
|
}
|
|
|
|
type XlenKey Incomplete
|
|
|
|
func (c XlenKey) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Xpending Incomplete
|
|
|
|
func (b Builder) Xpending() (c Xpending) {
|
|
c = Xpending{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XPENDING")
|
|
return c
|
|
}
|
|
|
|
func (c Xpending) Key(key string) XpendingKey {
|
|
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 (XpendingKey)(c)
|
|
}
|
|
|
|
type XpendingFiltersConsumer Incomplete
|
|
|
|
func (c XpendingFiltersConsumer) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XpendingFiltersCount Incomplete
|
|
|
|
func (c XpendingFiltersCount) Consumer(consumer string) XpendingFiltersConsumer {
|
|
c.cs.s = append(c.cs.s, consumer)
|
|
return (XpendingFiltersConsumer)(c)
|
|
}
|
|
|
|
func (c XpendingFiltersCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XpendingFiltersEnd Incomplete
|
|
|
|
func (c XpendingFiltersEnd) Count(count int64) XpendingFiltersCount {
|
|
c.cs.s = append(c.cs.s, strconv.FormatInt(count, 10))
|
|
return (XpendingFiltersCount)(c)
|
|
}
|
|
|
|
type XpendingFiltersIdle Incomplete
|
|
|
|
func (c XpendingFiltersIdle) Start(start string) XpendingFiltersStart {
|
|
c.cs.s = append(c.cs.s, start)
|
|
return (XpendingFiltersStart)(c)
|
|
}
|
|
|
|
type XpendingFiltersStart Incomplete
|
|
|
|
func (c XpendingFiltersStart) End(end string) XpendingFiltersEnd {
|
|
c.cs.s = append(c.cs.s, end)
|
|
return (XpendingFiltersEnd)(c)
|
|
}
|
|
|
|
type XpendingGroup Incomplete
|
|
|
|
func (c XpendingGroup) Idle(minIdleTime int64) XpendingFiltersIdle {
|
|
c.cs.s = append(c.cs.s, "IDLE", strconv.FormatInt(minIdleTime, 10))
|
|
return (XpendingFiltersIdle)(c)
|
|
}
|
|
|
|
func (c XpendingGroup) Start(start string) XpendingFiltersStart {
|
|
c.cs.s = append(c.cs.s, start)
|
|
return (XpendingFiltersStart)(c)
|
|
}
|
|
|
|
func (c XpendingGroup) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XpendingKey Incomplete
|
|
|
|
func (c XpendingKey) Group(group string) XpendingGroup {
|
|
c.cs.s = append(c.cs.s, group)
|
|
return (XpendingGroup)(c)
|
|
}
|
|
|
|
type Xrange Incomplete
|
|
|
|
func (b Builder) Xrange() (c Xrange) {
|
|
c = Xrange{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XRANGE")
|
|
return c
|
|
}
|
|
|
|
func (c Xrange) Key(key string) XrangeKey {
|
|
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 (XrangeKey)(c)
|
|
}
|
|
|
|
type XrangeCount Incomplete
|
|
|
|
func (c XrangeCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XrangeEnd Incomplete
|
|
|
|
func (c XrangeEnd) Count(count int64) XrangeCount {
|
|
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
|
|
return (XrangeCount)(c)
|
|
}
|
|
|
|
func (c XrangeEnd) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XrangeKey Incomplete
|
|
|
|
func (c XrangeKey) Start(start string) XrangeStart {
|
|
c.cs.s = append(c.cs.s, start)
|
|
return (XrangeStart)(c)
|
|
}
|
|
|
|
type XrangeStart Incomplete
|
|
|
|
func (c XrangeStart) End(end string) XrangeEnd {
|
|
c.cs.s = append(c.cs.s, end)
|
|
return (XrangeEnd)(c)
|
|
}
|
|
|
|
type Xread Incomplete
|
|
|
|
func (b Builder) Xread() (c Xread) {
|
|
c = Xread{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XREAD")
|
|
return c
|
|
}
|
|
|
|
func (c Xread) Count(count int64) XreadCount {
|
|
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
|
|
return (XreadCount)(c)
|
|
}
|
|
|
|
func (c Xread) Block(milliseconds int64) XreadBlock {
|
|
c.cf |= int16(blockTag)
|
|
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
|
|
return (XreadBlock)(c)
|
|
}
|
|
|
|
func (c Xread) Streams() XreadStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadStreams)(c)
|
|
}
|
|
|
|
type XreadBlock Incomplete
|
|
|
|
func (c XreadBlock) Streams() XreadStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadStreams)(c)
|
|
}
|
|
|
|
type XreadCount Incomplete
|
|
|
|
func (c XreadCount) Block(milliseconds int64) XreadBlock {
|
|
c.cf |= int16(blockTag)
|
|
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
|
|
return (XreadBlock)(c)
|
|
}
|
|
|
|
func (c XreadCount) Streams() XreadStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadStreams)(c)
|
|
}
|
|
|
|
type XreadId Incomplete
|
|
|
|
func (c XreadId) Id(id ...string) XreadId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XreadId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XreadKey Incomplete
|
|
|
|
func (c XreadKey) Key(key ...string) XreadKey {
|
|
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 XreadKey) Id(id ...string) XreadId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XreadId)(c)
|
|
}
|
|
|
|
type XreadStreams Incomplete
|
|
|
|
func (c XreadStreams) Key(key ...string) XreadKey {
|
|
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 (XreadKey)(c)
|
|
}
|
|
|
|
type Xreadgroup Incomplete
|
|
|
|
func (b Builder) Xreadgroup() (c Xreadgroup) {
|
|
c = Xreadgroup{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XREADGROUP")
|
|
return c
|
|
}
|
|
|
|
func (c Xreadgroup) Group(group string, consumer string) XreadgroupGroup {
|
|
c.cs.s = append(c.cs.s, "GROUP", group, consumer)
|
|
return (XreadgroupGroup)(c)
|
|
}
|
|
|
|
type XreadgroupBlock Incomplete
|
|
|
|
func (c XreadgroupBlock) Noack() XreadgroupNoack {
|
|
c.cs.s = append(c.cs.s, "NOACK")
|
|
return (XreadgroupNoack)(c)
|
|
}
|
|
|
|
func (c XreadgroupBlock) Streams() XreadgroupStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadgroupStreams)(c)
|
|
}
|
|
|
|
type XreadgroupCount Incomplete
|
|
|
|
func (c XreadgroupCount) Block(milliseconds int64) XreadgroupBlock {
|
|
c.cf |= int16(blockTag)
|
|
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
|
|
return (XreadgroupBlock)(c)
|
|
}
|
|
|
|
func (c XreadgroupCount) Noack() XreadgroupNoack {
|
|
c.cs.s = append(c.cs.s, "NOACK")
|
|
return (XreadgroupNoack)(c)
|
|
}
|
|
|
|
func (c XreadgroupCount) Streams() XreadgroupStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadgroupStreams)(c)
|
|
}
|
|
|
|
type XreadgroupGroup Incomplete
|
|
|
|
func (c XreadgroupGroup) Count(count int64) XreadgroupCount {
|
|
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
|
|
return (XreadgroupCount)(c)
|
|
}
|
|
|
|
func (c XreadgroupGroup) Block(milliseconds int64) XreadgroupBlock {
|
|
c.cf |= int16(blockTag)
|
|
c.cs.s = append(c.cs.s, "BLOCK", strconv.FormatInt(milliseconds, 10))
|
|
return (XreadgroupBlock)(c)
|
|
}
|
|
|
|
func (c XreadgroupGroup) Noack() XreadgroupNoack {
|
|
c.cs.s = append(c.cs.s, "NOACK")
|
|
return (XreadgroupNoack)(c)
|
|
}
|
|
|
|
func (c XreadgroupGroup) Streams() XreadgroupStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadgroupStreams)(c)
|
|
}
|
|
|
|
type XreadgroupId Incomplete
|
|
|
|
func (c XreadgroupId) Id(id ...string) XreadgroupId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return c
|
|
}
|
|
|
|
func (c XreadgroupId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XreadgroupKey Incomplete
|
|
|
|
func (c XreadgroupKey) Key(key ...string) XreadgroupKey {
|
|
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 XreadgroupKey) Id(id ...string) XreadgroupId {
|
|
c.cs.s = append(c.cs.s, id...)
|
|
return (XreadgroupId)(c)
|
|
}
|
|
|
|
type XreadgroupNoack Incomplete
|
|
|
|
func (c XreadgroupNoack) Streams() XreadgroupStreams {
|
|
c.cs.s = append(c.cs.s, "STREAMS")
|
|
return (XreadgroupStreams)(c)
|
|
}
|
|
|
|
type XreadgroupStreams Incomplete
|
|
|
|
func (c XreadgroupStreams) Key(key ...string) XreadgroupKey {
|
|
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 (XreadgroupKey)(c)
|
|
}
|
|
|
|
type Xrevrange Incomplete
|
|
|
|
func (b Builder) Xrevrange() (c Xrevrange) {
|
|
c = Xrevrange{cs: get(), ks: b.ks, cf: int16(readonly)}
|
|
c.cs.s = append(c.cs.s, "XREVRANGE")
|
|
return c
|
|
}
|
|
|
|
func (c Xrevrange) Key(key string) XrevrangeKey {
|
|
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 (XrevrangeKey)(c)
|
|
}
|
|
|
|
type XrevrangeCount Incomplete
|
|
|
|
func (c XrevrangeCount) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XrevrangeEnd Incomplete
|
|
|
|
func (c XrevrangeEnd) Start(start string) XrevrangeStart {
|
|
c.cs.s = append(c.cs.s, start)
|
|
return (XrevrangeStart)(c)
|
|
}
|
|
|
|
type XrevrangeKey Incomplete
|
|
|
|
func (c XrevrangeKey) End(end string) XrevrangeEnd {
|
|
c.cs.s = append(c.cs.s, end)
|
|
return (XrevrangeEnd)(c)
|
|
}
|
|
|
|
type XrevrangeStart Incomplete
|
|
|
|
func (c XrevrangeStart) Count(count int64) XrevrangeCount {
|
|
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
|
|
return (XrevrangeCount)(c)
|
|
}
|
|
|
|
func (c XrevrangeStart) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Xsetid Incomplete
|
|
|
|
func (b Builder) Xsetid() (c Xsetid) {
|
|
c = Xsetid{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XSETID")
|
|
return c
|
|
}
|
|
|
|
func (c Xsetid) Key(key string) XsetidKey {
|
|
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 (XsetidKey)(c)
|
|
}
|
|
|
|
type XsetidEntriesadded Incomplete
|
|
|
|
func (c XsetidEntriesadded) Maxdeletedid(maxDeletedEntryId string) XsetidMaxdeletedid {
|
|
c.cs.s = append(c.cs.s, "MAXDELETEDID", maxDeletedEntryId)
|
|
return (XsetidMaxdeletedid)(c)
|
|
}
|
|
|
|
func (c XsetidEntriesadded) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XsetidKey Incomplete
|
|
|
|
func (c XsetidKey) LastId(lastId string) XsetidLastId {
|
|
c.cs.s = append(c.cs.s, lastId)
|
|
return (XsetidLastId)(c)
|
|
}
|
|
|
|
type XsetidLastId Incomplete
|
|
|
|
func (c XsetidLastId) Entriesadded(entriesAdded int64) XsetidEntriesadded {
|
|
c.cs.s = append(c.cs.s, "ENTRIESADDED", strconv.FormatInt(entriesAdded, 10))
|
|
return (XsetidEntriesadded)(c)
|
|
}
|
|
|
|
func (c XsetidLastId) Maxdeletedid(maxDeletedEntryId string) XsetidMaxdeletedid {
|
|
c.cs.s = append(c.cs.s, "MAXDELETEDID", maxDeletedEntryId)
|
|
return (XsetidMaxdeletedid)(c)
|
|
}
|
|
|
|
func (c XsetidLastId) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XsetidMaxdeletedid Incomplete
|
|
|
|
func (c XsetidMaxdeletedid) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type Xtrim Incomplete
|
|
|
|
func (b Builder) Xtrim() (c Xtrim) {
|
|
c = Xtrim{cs: get(), ks: b.ks}
|
|
c.cs.s = append(c.cs.s, "XTRIM")
|
|
return c
|
|
}
|
|
|
|
func (c Xtrim) Key(key string) XtrimKey {
|
|
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 (XtrimKey)(c)
|
|
}
|
|
|
|
type XtrimKey Incomplete
|
|
|
|
func (c XtrimKey) Maxlen() XtrimTrimStrategyMaxlen {
|
|
c.cs.s = append(c.cs.s, "MAXLEN")
|
|
return (XtrimTrimStrategyMaxlen)(c)
|
|
}
|
|
|
|
func (c XtrimKey) Minid() XtrimTrimStrategyMinid {
|
|
c.cs.s = append(c.cs.s, "MINID")
|
|
return (XtrimTrimStrategyMinid)(c)
|
|
}
|
|
|
|
type XtrimTrimLimit Incomplete
|
|
|
|
func (c XtrimTrimLimit) Keepref() XtrimTrimReferenceKeepref {
|
|
c.cs.s = append(c.cs.s, "KEEPREF")
|
|
return (XtrimTrimReferenceKeepref)(c)
|
|
}
|
|
|
|
func (c XtrimTrimLimit) Delref() XtrimTrimReferenceDelref {
|
|
c.cs.s = append(c.cs.s, "DELREF")
|
|
return (XtrimTrimReferenceDelref)(c)
|
|
}
|
|
|
|
func (c XtrimTrimLimit) Acked() XtrimTrimReferenceAcked {
|
|
c.cs.s = append(c.cs.s, "ACKED")
|
|
return (XtrimTrimReferenceAcked)(c)
|
|
}
|
|
|
|
func (c XtrimTrimLimit) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XtrimTrimOperatorAlmost Incomplete
|
|
|
|
func (c XtrimTrimOperatorAlmost) Threshold(threshold string) XtrimTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XtrimTrimThreshold)(c)
|
|
}
|
|
|
|
type XtrimTrimOperatorExact Incomplete
|
|
|
|
func (c XtrimTrimOperatorExact) Threshold(threshold string) XtrimTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XtrimTrimThreshold)(c)
|
|
}
|
|
|
|
type XtrimTrimReferenceAcked Incomplete
|
|
|
|
func (c XtrimTrimReferenceAcked) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XtrimTrimReferenceDelref Incomplete
|
|
|
|
func (c XtrimTrimReferenceDelref) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XtrimTrimReferenceKeepref Incomplete
|
|
|
|
func (c XtrimTrimReferenceKeepref) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|
|
|
|
type XtrimTrimStrategyMaxlen Incomplete
|
|
|
|
func (c XtrimTrimStrategyMaxlen) Exact() XtrimTrimOperatorExact {
|
|
c.cs.s = append(c.cs.s, "=")
|
|
return (XtrimTrimOperatorExact)(c)
|
|
}
|
|
|
|
func (c XtrimTrimStrategyMaxlen) Almost() XtrimTrimOperatorAlmost {
|
|
c.cs.s = append(c.cs.s, "~")
|
|
return (XtrimTrimOperatorAlmost)(c)
|
|
}
|
|
|
|
func (c XtrimTrimStrategyMaxlen) Threshold(threshold string) XtrimTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XtrimTrimThreshold)(c)
|
|
}
|
|
|
|
type XtrimTrimStrategyMinid Incomplete
|
|
|
|
func (c XtrimTrimStrategyMinid) Exact() XtrimTrimOperatorExact {
|
|
c.cs.s = append(c.cs.s, "=")
|
|
return (XtrimTrimOperatorExact)(c)
|
|
}
|
|
|
|
func (c XtrimTrimStrategyMinid) Almost() XtrimTrimOperatorAlmost {
|
|
c.cs.s = append(c.cs.s, "~")
|
|
return (XtrimTrimOperatorAlmost)(c)
|
|
}
|
|
|
|
func (c XtrimTrimStrategyMinid) Threshold(threshold string) XtrimTrimThreshold {
|
|
c.cs.s = append(c.cs.s, threshold)
|
|
return (XtrimTrimThreshold)(c)
|
|
}
|
|
|
|
type XtrimTrimThreshold Incomplete
|
|
|
|
func (c XtrimTrimThreshold) Limit(count int64) XtrimTrimLimit {
|
|
c.cs.s = append(c.cs.s, "LIMIT", strconv.FormatInt(count, 10))
|
|
return (XtrimTrimLimit)(c)
|
|
}
|
|
|
|
func (c XtrimTrimThreshold) Keepref() XtrimTrimReferenceKeepref {
|
|
c.cs.s = append(c.cs.s, "KEEPREF")
|
|
return (XtrimTrimReferenceKeepref)(c)
|
|
}
|
|
|
|
func (c XtrimTrimThreshold) Delref() XtrimTrimReferenceDelref {
|
|
c.cs.s = append(c.cs.s, "DELREF")
|
|
return (XtrimTrimReferenceDelref)(c)
|
|
}
|
|
|
|
func (c XtrimTrimThreshold) Acked() XtrimTrimReferenceAcked {
|
|
c.cs.s = append(c.cs.s, "ACKED")
|
|
return (XtrimTrimReferenceAcked)(c)
|
|
}
|
|
|
|
func (c XtrimTrimThreshold) Build() Completed {
|
|
c.cs.Build()
|
|
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
|
|
}
|