internal/cmds/gen_cf.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)
}