rueian/rueidis

// Code generated DO NOT EDIT

package cmds

import "strconv"

type BfAdd Incomplete

func (b Builder) BfAdd() (c BfAdd) {
    c = BfAdd{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BF.ADD")
    return c
}

func (c BfAdd) Key(key string) BfAddKey {
    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 (BfAddKey)(c)
}

type BfAddItem Incomplete

func (c BfAddItem) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfAddKey Incomplete

func (c BfAddKey) Item(item string) BfAddItem {
    c.cs.s = append(c.cs.s, item)
    return (BfAddItem)(c)
}

type BfCard Incomplete

func (b Builder) BfCard() (c BfCard) {
    c = BfCard{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BF.CARD")
    return c
}

func (c BfCard) Key(key string) BfCardKey {
    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 (BfCardKey)(c)
}

type BfCardKey Incomplete

func (c BfCardKey) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfExists Incomplete

func (b Builder) BfExists() (c BfExists) {
    c = BfExists{cs: get(), ks: b.ks, cf: int16(readonly)}
    c.cs.s = append(c.cs.s, "BF.EXISTS")
    return c
}

func (c BfExists) Key(key string) BfExistsKey {
    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 (BfExistsKey)(c)
}

type BfExistsItem Incomplete

func (c BfExistsItem) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfExistsItem) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfExistsKey Incomplete

func (c BfExistsKey) Item(item string) BfExistsItem {
    c.cs.s = append(c.cs.s, item)
    return (BfExistsItem)(c)
}

type BfInfo Incomplete

func (b Builder) BfInfo() (c BfInfo) {
    c = BfInfo{cs: get(), ks: b.ks, cf: int16(readonly)}
    c.cs.s = append(c.cs.s, "BF.INFO")
    return c
}

func (c BfInfo) Key(key string) BfInfoKey {
    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 (BfInfoKey)(c)
}

type BfInfoKey Incomplete

func (c BfInfoKey) Capacity() BfInfoSingleValueCapacity {
    c.cs.s = append(c.cs.s, "CAPACITY")
    return (BfInfoSingleValueCapacity)(c)
}

func (c BfInfoKey) Size() BfInfoSingleValueSize {
    c.cs.s = append(c.cs.s, "SIZE")
    return (BfInfoSingleValueSize)(c)
}

func (c BfInfoKey) Filters() BfInfoSingleValueFilters {
    c.cs.s = append(c.cs.s, "FILTERS")
    return (BfInfoSingleValueFilters)(c)
}

func (c BfInfoKey) Items() BfInfoSingleValueItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInfoSingleValueItems)(c)
}

func (c BfInfoKey) Expansion() BfInfoSingleValueExpansion {
    c.cs.s = append(c.cs.s, "EXPANSION")
    return (BfInfoSingleValueExpansion)(c)
}

func (c BfInfoKey) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfInfoKey) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInfoSingleValueCapacity Incomplete

func (c BfInfoSingleValueCapacity) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfInfoSingleValueCapacity) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInfoSingleValueExpansion Incomplete

func (c BfInfoSingleValueExpansion) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfInfoSingleValueExpansion) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInfoSingleValueFilters Incomplete

func (c BfInfoSingleValueFilters) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfInfoSingleValueFilters) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInfoSingleValueItems Incomplete

func (c BfInfoSingleValueItems) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfInfoSingleValueItems) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInfoSingleValueSize Incomplete

func (c BfInfoSingleValueSize) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

func (c BfInfoSingleValueSize) Cache() Cacheable {
    c.cs.Build()
    return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInsert Incomplete

func (b Builder) BfInsert() (c BfInsert) {
    c = BfInsert{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BF.INSERT")
    return c
}

func (c BfInsert) Key(key string) BfInsertKey {
    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 (BfInsertKey)(c)
}

type BfInsertCapacity Incomplete

func (c BfInsertCapacity) Error(error float64) BfInsertError {
    c.cs.s = append(c.cs.s, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
    return (BfInsertError)(c)
}

func (c BfInsertCapacity) Expansion(expansion int64) BfInsertExpansion {
    c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
    return (BfInsertExpansion)(c)
}

func (c BfInsertCapacity) Nocreate() BfInsertNocreate {
    c.cs.s = append(c.cs.s, "NOCREATE")
    return (BfInsertNocreate)(c)
}

func (c BfInsertCapacity) Nonscaling() BfInsertNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfInsertNonscaling)(c)
}

func (c BfInsertCapacity) Items() BfInsertItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInsertItems)(c)
}

type BfInsertError Incomplete

func (c BfInsertError) Expansion(expansion int64) BfInsertExpansion {
    c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
    return (BfInsertExpansion)(c)
}

func (c BfInsertError) Nocreate() BfInsertNocreate {
    c.cs.s = append(c.cs.s, "NOCREATE")
    return (BfInsertNocreate)(c)
}

func (c BfInsertError) Nonscaling() BfInsertNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfInsertNonscaling)(c)
}

func (c BfInsertError) Items() BfInsertItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInsertItems)(c)
}

type BfInsertExpansion Incomplete

func (c BfInsertExpansion) Nocreate() BfInsertNocreate {
    c.cs.s = append(c.cs.s, "NOCREATE")
    return (BfInsertNocreate)(c)
}

func (c BfInsertExpansion) Nonscaling() BfInsertNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfInsertNonscaling)(c)
}

func (c BfInsertExpansion) Items() BfInsertItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInsertItems)(c)
}

type BfInsertItem Incomplete

func (c BfInsertItem) Item(item ...string) BfInsertItem {
    c.cs.s = append(c.cs.s, item...)
    return c
}

func (c BfInsertItem) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfInsertItems Incomplete

func (c BfInsertItems) Item(item ...string) BfInsertItem {
    c.cs.s = append(c.cs.s, item...)
    return (BfInsertItem)(c)
}

type BfInsertKey Incomplete

func (c BfInsertKey) Capacity(capacity int64) BfInsertCapacity {
    c.cs.s = append(c.cs.s, "CAPACITY", strconv.FormatInt(capacity, 10))
    return (BfInsertCapacity)(c)
}

func (c BfInsertKey) Error(error float64) BfInsertError {
    c.cs.s = append(c.cs.s, "ERROR", strconv.FormatFloat(error, 'f', -1, 64))
    return (BfInsertError)(c)
}

func (c BfInsertKey) Expansion(expansion int64) BfInsertExpansion {
    c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
    return (BfInsertExpansion)(c)
}

func (c BfInsertKey) Nocreate() BfInsertNocreate {
    c.cs.s = append(c.cs.s, "NOCREATE")
    return (BfInsertNocreate)(c)
}

func (c BfInsertKey) Nonscaling() BfInsertNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfInsertNonscaling)(c)
}

func (c BfInsertKey) Items() BfInsertItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInsertItems)(c)
}

type BfInsertNocreate Incomplete

func (c BfInsertNocreate) Nonscaling() BfInsertNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfInsertNonscaling)(c)
}

func (c BfInsertNocreate) Items() BfInsertItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInsertItems)(c)
}

type BfInsertNonscaling Incomplete

func (c BfInsertNonscaling) Items() BfInsertItems {
    c.cs.s = append(c.cs.s, "ITEMS")
    return (BfInsertItems)(c)
}

type BfLoadchunk Incomplete

func (b Builder) BfLoadchunk() (c BfLoadchunk) {
    c = BfLoadchunk{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BF.LOADCHUNK")
    return c
}

func (c BfLoadchunk) Key(key string) BfLoadchunkKey {
    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 (BfLoadchunkKey)(c)
}

type BfLoadchunkData Incomplete

func (c BfLoadchunkData) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfLoadchunkIterator Incomplete

func (c BfLoadchunkIterator) Data(data string) BfLoadchunkData {
    c.cs.s = append(c.cs.s, data)
    return (BfLoadchunkData)(c)
}

type BfLoadchunkKey Incomplete

func (c BfLoadchunkKey) Iterator(iterator int64) BfLoadchunkIterator {
    c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
    return (BfLoadchunkIterator)(c)
}

type BfMadd Incomplete

func (b Builder) BfMadd() (c BfMadd) {
    c = BfMadd{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BF.MADD")
    return c
}

func (c BfMadd) Key(key string) BfMaddKey {
    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 (BfMaddKey)(c)
}

type BfMaddItem Incomplete

func (c BfMaddItem) Item(item ...string) BfMaddItem {
    c.cs.s = append(c.cs.s, item...)
    return c
}

func (c BfMaddItem) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfMaddKey Incomplete

func (c BfMaddKey) Item(item ...string) BfMaddItem {
    c.cs.s = append(c.cs.s, item...)
    return (BfMaddItem)(c)
}

type BfMexists Incomplete

func (b Builder) BfMexists() (c BfMexists) {
    c = BfMexists{cs: get(), ks: b.ks, cf: int16(readonly)}
    c.cs.s = append(c.cs.s, "BF.MEXISTS")
    return c
}

func (c BfMexists) Key(key string) BfMexistsKey {
    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 (BfMexistsKey)(c)
}

type BfMexistsItem Incomplete

func (c BfMexistsItem) Item(item ...string) BfMexistsItem {
    c.cs.s = append(c.cs.s, item...)
    return c
}

func (c BfMexistsItem) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfMexistsKey Incomplete

func (c BfMexistsKey) Item(item ...string) BfMexistsItem {
    c.cs.s = append(c.cs.s, item...)
    return (BfMexistsItem)(c)
}

type BfReserve Incomplete

func (b Builder) BfReserve() (c BfReserve) {
    c = BfReserve{cs: get(), ks: b.ks}
    c.cs.s = append(c.cs.s, "BF.RESERVE")
    return c
}

func (c BfReserve) Key(key string) BfReserveKey {
    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 (BfReserveKey)(c)
}

type BfReserveCapacity Incomplete

func (c BfReserveCapacity) Expansion(expansion int64) BfReserveExpansion {
    c.cs.s = append(c.cs.s, "EXPANSION", strconv.FormatInt(expansion, 10))
    return (BfReserveExpansion)(c)
}

func (c BfReserveCapacity) Nonscaling() BfReserveNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfReserveNonscaling)(c)
}

func (c BfReserveCapacity) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfReserveErrorRate Incomplete

func (c BfReserveErrorRate) Capacity(capacity int64) BfReserveCapacity {
    c.cs.s = append(c.cs.s, strconv.FormatInt(capacity, 10))
    return (BfReserveCapacity)(c)
}

type BfReserveExpansion Incomplete

func (c BfReserveExpansion) Nonscaling() BfReserveNonscaling {
    c.cs.s = append(c.cs.s, "NONSCALING")
    return (BfReserveNonscaling)(c)
}

func (c BfReserveExpansion) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfReserveKey Incomplete

func (c BfReserveKey) ErrorRate(errorRate float64) BfReserveErrorRate {
    c.cs.s = append(c.cs.s, strconv.FormatFloat(errorRate, 'f', -1, 64))
    return (BfReserveErrorRate)(c)
}

type BfReserveNonscaling Incomplete

func (c BfReserveNonscaling) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfScandump Incomplete

func (b Builder) BfScandump() (c BfScandump) {
    c = BfScandump{cs: get(), ks: b.ks, cf: int16(readonly)}
    c.cs.s = append(c.cs.s, "BF.SCANDUMP")
    return c
}

func (c BfScandump) Key(key string) BfScandumpKey {
    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 (BfScandumpKey)(c)
}

type BfScandumpIterator Incomplete

func (c BfScandumpIterator) Build() Completed {
    c.cs.Build()
    return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}

type BfScandumpKey Incomplete

func (c BfScandumpKey) Iterator(iterator int64) BfScandumpIterator {
    c.cs.s = append(c.cs.s, strconv.FormatInt(iterator, 10))
    return (BfScandumpIterator)(c)
}