claude/mattermost-community-enterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
ec1f89217a
mattermost-community-enterp.../vendor/github.com/redis/rueidis/internal/cmds/gen_geo.go
Claude ec1f89217a Merge: Complete Mattermost Server with Community Enterprise 
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>
2025-12-17 23:59:07 +09:00

3512 lines
97 KiB
Go
Raw Blame History

// Code generated DO NOT EDIT
package cmds
import "strconv"
type Geoadd Incomplete
func (b Builder) Geoadd() (c Geoadd) {
c = Geoadd{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GEOADD")
return c
}
func (c Geoadd) Key(key string) GeoaddKey {
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 (GeoaddKey)(c)
}
type GeoaddChangeCh Incomplete
func (c GeoaddChangeCh) LongitudeLatitudeMember() GeoaddLongitudeLatitudeMember {
return (GeoaddLongitudeLatitudeMember)(c)
}
type GeoaddConditionNx Incomplete
func (c GeoaddConditionNx) Ch() GeoaddChangeCh {
c.cs.s = append(c.cs.s, "CH")
return (GeoaddChangeCh)(c)
}
func (c GeoaddConditionNx) LongitudeLatitudeMember() GeoaddLongitudeLatitudeMember {
return (GeoaddLongitudeLatitudeMember)(c)
}
type GeoaddConditionXx Incomplete
func (c GeoaddConditionXx) Ch() GeoaddChangeCh {
c.cs.s = append(c.cs.s, "CH")
return (GeoaddChangeCh)(c)
}
func (c GeoaddConditionXx) LongitudeLatitudeMember() GeoaddLongitudeLatitudeMember {
return (GeoaddLongitudeLatitudeMember)(c)
}
type GeoaddKey Incomplete
func (c GeoaddKey) Nx() GeoaddConditionNx {
c.cs.s = append(c.cs.s, "NX")
return (GeoaddConditionNx)(c)
}
func (c GeoaddKey) Xx() GeoaddConditionXx {
c.cs.s = append(c.cs.s, "XX")
return (GeoaddConditionXx)(c)
}
func (c GeoaddKey) Ch() GeoaddChangeCh {
c.cs.s = append(c.cs.s, "CH")
return (GeoaddChangeCh)(c)
}
func (c GeoaddKey) LongitudeLatitudeMember() GeoaddLongitudeLatitudeMember {
return (GeoaddLongitudeLatitudeMember)(c)
}
type GeoaddLongitudeLatitudeMember Incomplete
func (c GeoaddLongitudeLatitudeMember) LongitudeLatitudeMember(longitude float64, latitude float64, member string) GeoaddLongitudeLatitudeMember {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64), member)
return c
}
func (c GeoaddLongitudeLatitudeMember) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Geodist Incomplete
func (b Builder) Geodist() (c Geodist) {
c = Geodist{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GEODIST")
return c
}
func (c Geodist) Key(key string) GeodistKey {
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 (GeodistKey)(c)
}
type GeodistKey Incomplete
func (c GeodistKey) Member1(member1 string) GeodistMember1 {
c.cs.s = append(c.cs.s, member1)
return (GeodistMember1)(c)
}
type GeodistMember1 Incomplete
func (c GeodistMember1) Member2(member2 string) GeodistMember2 {
c.cs.s = append(c.cs.s, member2)
return (GeodistMember2)(c)
}
type GeodistMember2 Incomplete
func (c GeodistMember2) M() GeodistUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeodistUnitM)(c)
}
func (c GeodistMember2) Km() GeodistUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeodistUnitKm)(c)
}
func (c GeodistMember2) Ft() GeodistUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeodistUnitFt)(c)
}
func (c GeodistMember2) Mi() GeodistUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeodistUnitMi)(c)
}
func (c GeodistMember2) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeodistMember2) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeodistUnitFt Incomplete
func (c GeodistUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeodistUnitFt) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeodistUnitKm Incomplete
func (c GeodistUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeodistUnitKm) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeodistUnitM Incomplete
func (c GeodistUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeodistUnitM) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeodistUnitMi Incomplete
func (c GeodistUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeodistUnitMi) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Geohash Incomplete
func (b Builder) Geohash() (c Geohash) {
c = Geohash{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GEOHASH")
return c
}
func (c Geohash) Key(key string) GeohashKey {
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 (GeohashKey)(c)
}
type GeohashKey Incomplete
func (c GeohashKey) Member(member ...string) GeohashMember {
c.cs.s = append(c.cs.s, member...)
return (GeohashMember)(c)
}
func (c GeohashKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeohashKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeohashMember Incomplete
func (c GeohashMember) Member(member ...string) GeohashMember {
c.cs.s = append(c.cs.s, member...)
return c
}
func (c GeohashMember) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeohashMember) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Geopos Incomplete
func (b Builder) Geopos() (c Geopos) {
c = Geopos{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GEOPOS")
return c
}
func (c Geopos) Key(key string) GeoposKey {
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 (GeoposKey)(c)
}
type GeoposKey Incomplete
func (c GeoposKey) Member(member ...string) GeoposMember {
c.cs.s = append(c.cs.s, member...)
return (GeoposMember)(c)
}
func (c GeoposKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoposKey) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoposMember Incomplete
func (c GeoposMember) Member(member ...string) GeoposMember {
c.cs.s = append(c.cs.s, member...)
return c
}
func (c GeoposMember) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoposMember) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Georadius Incomplete
func (b Builder) Georadius() (c Georadius) {
c = Georadius{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GEORADIUS")
return c
}
func (c Georadius) Key(key string) GeoradiusKey {
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 (GeoradiusKey)(c)
}
type GeoradiusCountAny Incomplete
func (c GeoradiusCountAny) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusCountAny) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusCountAny) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusCountAny) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusCountAny) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusCountCount Incomplete
func (c GeoradiusCountCount) Any() GeoradiusCountAny {
c.cs.s = append(c.cs.s, "ANY")
return (GeoradiusCountAny)(c)
}
func (c GeoradiusCountCount) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusCountCount) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusCountCount) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusCountCount) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusKey Incomplete
func (c GeoradiusKey) Longitude(longitude float64) GeoradiusLongitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
return (GeoradiusLongitude)(c)
}
type GeoradiusLatitude Incomplete
func (c GeoradiusLatitude) Radius(radius float64) GeoradiusRadius {
c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
return (GeoradiusRadius)(c)
}
type GeoradiusLongitude Incomplete
func (c GeoradiusLongitude) Latitude(latitude float64) GeoradiusLatitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeoradiusLatitude)(c)
}
type GeoradiusOrderAsc Incomplete
func (c GeoradiusOrderAsc) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusOrderAsc) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusOrderAsc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusOrderDesc Incomplete
func (c GeoradiusOrderDesc) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusOrderDesc) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusOrderDesc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRadius Incomplete
func (c GeoradiusRadius) M() GeoradiusUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeoradiusUnitM)(c)
}
func (c GeoradiusRadius) Km() GeoradiusUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeoradiusUnitKm)(c)
}
func (c GeoradiusRadius) Ft() GeoradiusUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeoradiusUnitFt)(c)
}
func (c GeoradiusRadius) Mi() GeoradiusUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeoradiusUnitMi)(c)
}
type GeoradiusRo Incomplete
func (b Builder) GeoradiusRo() (c GeoradiusRo) {
c = GeoradiusRo{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GEORADIUS_RO")
return c
}
func (c GeoradiusRo) Key(key string) GeoradiusRoKey {
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 (GeoradiusRoKey)(c)
}
type GeoradiusRoCountAny Incomplete
func (c GeoradiusRoCountAny) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoCountAny) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoCountAny) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoCountAny) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoCountCount Incomplete
func (c GeoradiusRoCountCount) Any() GeoradiusRoCountAny {
c.cs.s = append(c.cs.s, "ANY")
return (GeoradiusRoCountAny)(c)
}
func (c GeoradiusRoCountCount) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoCountCount) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoCountCount) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoKey Incomplete
func (c GeoradiusRoKey) Longitude(longitude float64) GeoradiusRoLongitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
return (GeoradiusRoLongitude)(c)
}
type GeoradiusRoLatitude Incomplete
func (c GeoradiusRoLatitude) Radius(radius float64) GeoradiusRoRadius {
c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
return (GeoradiusRoRadius)(c)
}
type GeoradiusRoLongitude Incomplete
func (c GeoradiusRoLongitude) Latitude(latitude float64) GeoradiusRoLatitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeoradiusRoLatitude)(c)
}
type GeoradiusRoOrderAsc Incomplete
func (c GeoradiusRoOrderAsc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoOrderAsc) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoOrderDesc Incomplete
func (c GeoradiusRoOrderDesc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoOrderDesc) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoRadius Incomplete
func (c GeoradiusRoRadius) M() GeoradiusRoUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeoradiusRoUnitM)(c)
}
func (c GeoradiusRoRadius) Km() GeoradiusRoUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeoradiusRoUnitKm)(c)
}
func (c GeoradiusRoRadius) Ft() GeoradiusRoUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeoradiusRoUnitFt)(c)
}
func (c GeoradiusRoRadius) Mi() GeoradiusRoUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeoradiusRoUnitMi)(c)
}
type GeoradiusRoUnitFt Incomplete
func (c GeoradiusRoUnitFt) Withcoord() GeoradiusRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusRoWithcoord)(c)
}
func (c GeoradiusRoUnitFt) Withdist() GeoradiusRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusRoWithdist)(c)
}
func (c GeoradiusRoUnitFt) Withhash() GeoradiusRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusRoWithhash)(c)
}
func (c GeoradiusRoUnitFt) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoUnitFt) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoUnitFt) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoUnitFt) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoUnitKm Incomplete
func (c GeoradiusRoUnitKm) Withcoord() GeoradiusRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusRoWithcoord)(c)
}
func (c GeoradiusRoUnitKm) Withdist() GeoradiusRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusRoWithdist)(c)
}
func (c GeoradiusRoUnitKm) Withhash() GeoradiusRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusRoWithhash)(c)
}
func (c GeoradiusRoUnitKm) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoUnitKm) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoUnitKm) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoUnitKm) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoUnitM Incomplete
func (c GeoradiusRoUnitM) Withcoord() GeoradiusRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusRoWithcoord)(c)
}
func (c GeoradiusRoUnitM) Withdist() GeoradiusRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusRoWithdist)(c)
}
func (c GeoradiusRoUnitM) Withhash() GeoradiusRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusRoWithhash)(c)
}
func (c GeoradiusRoUnitM) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoUnitM) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoUnitM) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoUnitM) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoUnitMi Incomplete
func (c GeoradiusRoUnitMi) Withcoord() GeoradiusRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusRoWithcoord)(c)
}
func (c GeoradiusRoUnitMi) Withdist() GeoradiusRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusRoWithdist)(c)
}
func (c GeoradiusRoUnitMi) Withhash() GeoradiusRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusRoWithhash)(c)
}
func (c GeoradiusRoUnitMi) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoUnitMi) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoUnitMi) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoUnitMi) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoWithcoord Incomplete
func (c GeoradiusRoWithcoord) Withdist() GeoradiusRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusRoWithdist)(c)
}
func (c GeoradiusRoWithcoord) Withhash() GeoradiusRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusRoWithhash)(c)
}
func (c GeoradiusRoWithcoord) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoWithcoord) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoWithcoord) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoWithcoord) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoWithcoord) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoWithdist Incomplete
func (c GeoradiusRoWithdist) Withhash() GeoradiusRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusRoWithhash)(c)
}
func (c GeoradiusRoWithdist) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoWithdist) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoWithdist) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoWithdist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoWithdist) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusRoWithhash Incomplete
func (c GeoradiusRoWithhash) Count(count int64) GeoradiusRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusRoCountCount)(c)
}
func (c GeoradiusRoWithhash) Asc() GeoradiusRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusRoOrderAsc)(c)
}
func (c GeoradiusRoWithhash) Desc() GeoradiusRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusRoOrderDesc)(c)
}
func (c GeoradiusRoWithhash) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusRoWithhash) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusStoreKey Incomplete
func (c GeoradiusStoreKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusStoredistKey Incomplete
func (c GeoradiusStoredistKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusUnitFt Incomplete
func (c GeoradiusUnitFt) Withcoord() GeoradiusWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusWithcoord)(c)
}
func (c GeoradiusUnitFt) Withdist() GeoradiusWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusWithdist)(c)
}
func (c GeoradiusUnitFt) Withhash() GeoradiusWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusWithhash)(c)
}
func (c GeoradiusUnitFt) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusUnitFt) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusUnitFt) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusUnitFt) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusUnitFt) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusUnitKm Incomplete
func (c GeoradiusUnitKm) Withcoord() GeoradiusWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusWithcoord)(c)
}
func (c GeoradiusUnitKm) Withdist() GeoradiusWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusWithdist)(c)
}
func (c GeoradiusUnitKm) Withhash() GeoradiusWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusWithhash)(c)
}
func (c GeoradiusUnitKm) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusUnitKm) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusUnitKm) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusUnitKm) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusUnitKm) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusUnitM Incomplete
func (c GeoradiusUnitM) Withcoord() GeoradiusWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusWithcoord)(c)
}
func (c GeoradiusUnitM) Withdist() GeoradiusWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusWithdist)(c)
}
func (c GeoradiusUnitM) Withhash() GeoradiusWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusWithhash)(c)
}
func (c GeoradiusUnitM) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusUnitM) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusUnitM) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusUnitM) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusUnitM) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusUnitMi Incomplete
func (c GeoradiusUnitMi) Withcoord() GeoradiusWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusWithcoord)(c)
}
func (c GeoradiusUnitMi) Withdist() GeoradiusWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusWithdist)(c)
}
func (c GeoradiusUnitMi) Withhash() GeoradiusWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusWithhash)(c)
}
func (c GeoradiusUnitMi) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusUnitMi) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusUnitMi) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusUnitMi) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusUnitMi) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusWithcoord Incomplete
func (c GeoradiusWithcoord) Withdist() GeoradiusWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusWithdist)(c)
}
func (c GeoradiusWithcoord) Withhash() GeoradiusWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusWithhash)(c)
}
func (c GeoradiusWithcoord) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusWithcoord) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusWithcoord) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusWithcoord) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusWithcoord) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusWithcoord) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusWithdist Incomplete
func (c GeoradiusWithdist) Withhash() GeoradiusWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusWithhash)(c)
}
func (c GeoradiusWithdist) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusWithdist) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusWithdist) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusWithdist) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusWithdist) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusWithdist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusWithhash Incomplete
func (c GeoradiusWithhash) Count(count int64) GeoradiusCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusCountCount)(c)
}
func (c GeoradiusWithhash) Asc() GeoradiusOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusOrderAsc)(c)
}
func (c GeoradiusWithhash) Desc() GeoradiusOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusOrderDesc)(c)
}
func (c GeoradiusWithhash) Store(key string) GeoradiusStoreKey {
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, "STORE", key)
return (GeoradiusStoreKey)(c)
}
func (c GeoradiusWithhash) Storedist(key string) GeoradiusStoredistKey {
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, "STOREDIST", key)
return (GeoradiusStoredistKey)(c)
}
func (c GeoradiusWithhash) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Georadiusbymember Incomplete
func (b Builder) Georadiusbymember() (c Georadiusbymember) {
c = Georadiusbymember{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GEORADIUSBYMEMBER")
return c
}
func (c Georadiusbymember) Key(key string) GeoradiusbymemberKey {
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 (GeoradiusbymemberKey)(c)
}
type GeoradiusbymemberCountAny Incomplete
func (c GeoradiusbymemberCountAny) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberCountAny) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberCountAny) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberCountAny) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberCountAny) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberCountCount Incomplete
func (c GeoradiusbymemberCountCount) Any() GeoradiusbymemberCountAny {
c.cs.s = append(c.cs.s, "ANY")
return (GeoradiusbymemberCountAny)(c)
}
func (c GeoradiusbymemberCountCount) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberCountCount) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberCountCount) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberCountCount) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberKey Incomplete
func (c GeoradiusbymemberKey) Member(member string) GeoradiusbymemberMember {
c.cs.s = append(c.cs.s, member)
return (GeoradiusbymemberMember)(c)
}
type GeoradiusbymemberMember Incomplete
func (c GeoradiusbymemberMember) Radius(radius float64) GeoradiusbymemberRadius {
c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
return (GeoradiusbymemberRadius)(c)
}
type GeoradiusbymemberOrderAsc Incomplete
func (c GeoradiusbymemberOrderAsc) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberOrderAsc) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberOrderAsc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberOrderDesc Incomplete
func (c GeoradiusbymemberOrderDesc) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberOrderDesc) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberOrderDesc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRadius Incomplete
func (c GeoradiusbymemberRadius) M() GeoradiusbymemberUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeoradiusbymemberUnitM)(c)
}
func (c GeoradiusbymemberRadius) Km() GeoradiusbymemberUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeoradiusbymemberUnitKm)(c)
}
func (c GeoradiusbymemberRadius) Ft() GeoradiusbymemberUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeoradiusbymemberUnitFt)(c)
}
func (c GeoradiusbymemberRadius) Mi() GeoradiusbymemberUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeoradiusbymemberUnitMi)(c)
}
type GeoradiusbymemberRo Incomplete
func (b Builder) GeoradiusbymemberRo() (c GeoradiusbymemberRo) {
c = GeoradiusbymemberRo{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GEORADIUSBYMEMBER_RO")
return c
}
func (c GeoradiusbymemberRo) Key(key string) GeoradiusbymemberRoKey {
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 (GeoradiusbymemberRoKey)(c)
}
type GeoradiusbymemberRoCountAny Incomplete
func (c GeoradiusbymemberRoCountAny) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoCountAny) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoCountAny) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoCountAny) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoCountCount Incomplete
func (c GeoradiusbymemberRoCountCount) Any() GeoradiusbymemberRoCountAny {
c.cs.s = append(c.cs.s, "ANY")
return (GeoradiusbymemberRoCountAny)(c)
}
func (c GeoradiusbymemberRoCountCount) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoCountCount) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoCountCount) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoKey Incomplete
func (c GeoradiusbymemberRoKey) Member(member string) GeoradiusbymemberRoMember {
c.cs.s = append(c.cs.s, member)
return (GeoradiusbymemberRoMember)(c)
}
type GeoradiusbymemberRoMember Incomplete
func (c GeoradiusbymemberRoMember) Radius(radius float64) GeoradiusbymemberRoRadius {
c.cs.s = append(c.cs.s, strconv.FormatFloat(radius, 'f', -1, 64))
return (GeoradiusbymemberRoRadius)(c)
}
type GeoradiusbymemberRoOrderAsc Incomplete
func (c GeoradiusbymemberRoOrderAsc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoOrderAsc) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoOrderDesc Incomplete
func (c GeoradiusbymemberRoOrderDesc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoOrderDesc) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoRadius Incomplete
func (c GeoradiusbymemberRoRadius) M() GeoradiusbymemberRoUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeoradiusbymemberRoUnitM)(c)
}
func (c GeoradiusbymemberRoRadius) Km() GeoradiusbymemberRoUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeoradiusbymemberRoUnitKm)(c)
}
func (c GeoradiusbymemberRoRadius) Ft() GeoradiusbymemberRoUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeoradiusbymemberRoUnitFt)(c)
}
func (c GeoradiusbymemberRoRadius) Mi() GeoradiusbymemberRoUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeoradiusbymemberRoUnitMi)(c)
}
type GeoradiusbymemberRoUnitFt Incomplete
func (c GeoradiusbymemberRoUnitFt) Withcoord() GeoradiusbymemberRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberRoWithcoord)(c)
}
func (c GeoradiusbymemberRoUnitFt) Withdist() GeoradiusbymemberRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberRoWithdist)(c)
}
func (c GeoradiusbymemberRoUnitFt) Withhash() GeoradiusbymemberRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberRoWithhash)(c)
}
func (c GeoradiusbymemberRoUnitFt) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoUnitFt) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoUnitFt) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoUnitFt) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoUnitKm Incomplete
func (c GeoradiusbymemberRoUnitKm) Withcoord() GeoradiusbymemberRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberRoWithcoord)(c)
}
func (c GeoradiusbymemberRoUnitKm) Withdist() GeoradiusbymemberRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberRoWithdist)(c)
}
func (c GeoradiusbymemberRoUnitKm) Withhash() GeoradiusbymemberRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberRoWithhash)(c)
}
func (c GeoradiusbymemberRoUnitKm) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoUnitKm) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoUnitKm) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoUnitKm) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoUnitM Incomplete
func (c GeoradiusbymemberRoUnitM) Withcoord() GeoradiusbymemberRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberRoWithcoord)(c)
}
func (c GeoradiusbymemberRoUnitM) Withdist() GeoradiusbymemberRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberRoWithdist)(c)
}
func (c GeoradiusbymemberRoUnitM) Withhash() GeoradiusbymemberRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberRoWithhash)(c)
}
func (c GeoradiusbymemberRoUnitM) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoUnitM) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoUnitM) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoUnitM) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoUnitMi Incomplete
func (c GeoradiusbymemberRoUnitMi) Withcoord() GeoradiusbymemberRoWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberRoWithcoord)(c)
}
func (c GeoradiusbymemberRoUnitMi) Withdist() GeoradiusbymemberRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberRoWithdist)(c)
}
func (c GeoradiusbymemberRoUnitMi) Withhash() GeoradiusbymemberRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberRoWithhash)(c)
}
func (c GeoradiusbymemberRoUnitMi) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoUnitMi) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoUnitMi) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoUnitMi) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoWithcoord Incomplete
func (c GeoradiusbymemberRoWithcoord) Withdist() GeoradiusbymemberRoWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberRoWithdist)(c)
}
func (c GeoradiusbymemberRoWithcoord) Withhash() GeoradiusbymemberRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberRoWithhash)(c)
}
func (c GeoradiusbymemberRoWithcoord) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoWithcoord) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoWithcoord) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoWithcoord) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoWithcoord) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoWithdist Incomplete
func (c GeoradiusbymemberRoWithdist) Withhash() GeoradiusbymemberRoWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberRoWithhash)(c)
}
func (c GeoradiusbymemberRoWithdist) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoWithdist) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoWithdist) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoWithdist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoWithdist) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberRoWithhash Incomplete
func (c GeoradiusbymemberRoWithhash) Count(count int64) GeoradiusbymemberRoCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberRoCountCount)(c)
}
func (c GeoradiusbymemberRoWithhash) Asc() GeoradiusbymemberRoOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberRoOrderAsc)(c)
}
func (c GeoradiusbymemberRoWithhash) Desc() GeoradiusbymemberRoOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberRoOrderDesc)(c)
}
func (c GeoradiusbymemberRoWithhash) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeoradiusbymemberRoWithhash) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberStoreStoreKey Incomplete
func (c GeoradiusbymemberStoreStoreKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberStoreStoredistKey Incomplete
func (c GeoradiusbymemberStoreStoredistKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberUnitFt Incomplete
func (c GeoradiusbymemberUnitFt) Withcoord() GeoradiusbymemberWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberWithcoord)(c)
}
func (c GeoradiusbymemberUnitFt) Withdist() GeoradiusbymemberWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberWithdist)(c)
}
func (c GeoradiusbymemberUnitFt) Withhash() GeoradiusbymemberWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberWithhash)(c)
}
func (c GeoradiusbymemberUnitFt) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberUnitFt) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberUnitFt) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberUnitFt) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberUnitFt) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberUnitKm Incomplete
func (c GeoradiusbymemberUnitKm) Withcoord() GeoradiusbymemberWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberWithcoord)(c)
}
func (c GeoradiusbymemberUnitKm) Withdist() GeoradiusbymemberWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberWithdist)(c)
}
func (c GeoradiusbymemberUnitKm) Withhash() GeoradiusbymemberWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberWithhash)(c)
}
func (c GeoradiusbymemberUnitKm) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberUnitKm) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberUnitKm) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberUnitKm) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberUnitKm) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberUnitM Incomplete
func (c GeoradiusbymemberUnitM) Withcoord() GeoradiusbymemberWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberWithcoord)(c)
}
func (c GeoradiusbymemberUnitM) Withdist() GeoradiusbymemberWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberWithdist)(c)
}
func (c GeoradiusbymemberUnitM) Withhash() GeoradiusbymemberWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberWithhash)(c)
}
func (c GeoradiusbymemberUnitM) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberUnitM) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberUnitM) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberUnitM) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberUnitM) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberUnitMi Incomplete
func (c GeoradiusbymemberUnitMi) Withcoord() GeoradiusbymemberWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeoradiusbymemberWithcoord)(c)
}
func (c GeoradiusbymemberUnitMi) Withdist() GeoradiusbymemberWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberWithdist)(c)
}
func (c GeoradiusbymemberUnitMi) Withhash() GeoradiusbymemberWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberWithhash)(c)
}
func (c GeoradiusbymemberUnitMi) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberUnitMi) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberUnitMi) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberUnitMi) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberUnitMi) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberWithcoord Incomplete
func (c GeoradiusbymemberWithcoord) Withdist() GeoradiusbymemberWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeoradiusbymemberWithdist)(c)
}
func (c GeoradiusbymemberWithcoord) Withhash() GeoradiusbymemberWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberWithhash)(c)
}
func (c GeoradiusbymemberWithcoord) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberWithcoord) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberWithcoord) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberWithcoord) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberWithcoord) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberWithcoord) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberWithdist Incomplete
func (c GeoradiusbymemberWithdist) Withhash() GeoradiusbymemberWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeoradiusbymemberWithhash)(c)
}
func (c GeoradiusbymemberWithdist) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberWithdist) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberWithdist) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberWithdist) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberWithdist) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberWithdist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeoradiusbymemberWithhash Incomplete
func (c GeoradiusbymemberWithhash) Count(count int64) GeoradiusbymemberCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeoradiusbymemberCountCount)(c)
}
func (c GeoradiusbymemberWithhash) Asc() GeoradiusbymemberOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeoradiusbymemberOrderAsc)(c)
}
func (c GeoradiusbymemberWithhash) Desc() GeoradiusbymemberOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeoradiusbymemberOrderDesc)(c)
}
func (c GeoradiusbymemberWithhash) Store(key string) GeoradiusbymemberStoreStoreKey {
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, "STORE", key)
return (GeoradiusbymemberStoreStoreKey)(c)
}
func (c GeoradiusbymemberWithhash) Storedist(key string) GeoradiusbymemberStoreStoredistKey {
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, "STOREDIST", key)
return (GeoradiusbymemberStoreStoredistKey)(c)
}
func (c GeoradiusbymemberWithhash) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Geosearch Incomplete
func (b Builder) Geosearch() (c Geosearch) {
c = Geosearch{cs: get(), ks: b.ks, cf: int16(readonly)}
c.cs.s = append(c.cs.s, "GEOSEARCH")
return c
}
func (c Geosearch) Key(key string) GeosearchKey {
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 (GeosearchKey)(c)
}
type GeosearchCircleBoxBybox Incomplete
func (c GeosearchCircleBoxBybox) Height(height float64) GeosearchCircleBoxHeight {
c.cs.s = append(c.cs.s, strconv.FormatFloat(height, 'f', -1, 64))
return (GeosearchCircleBoxHeight)(c)
}
type GeosearchCircleBoxHeight Incomplete
func (c GeosearchCircleBoxHeight) M() GeosearchCircleBoxUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeosearchCircleBoxUnitM)(c)
}
func (c GeosearchCircleBoxHeight) Km() GeosearchCircleBoxUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeosearchCircleBoxUnitKm)(c)
}
func (c GeosearchCircleBoxHeight) Ft() GeosearchCircleBoxUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeosearchCircleBoxUnitFt)(c)
}
func (c GeosearchCircleBoxHeight) Mi() GeosearchCircleBoxUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeosearchCircleBoxUnitMi)(c)
}
type GeosearchCircleBoxUnitFt Incomplete
func (c GeosearchCircleBoxUnitFt) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleBoxUnitFt) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleBoxUnitFt) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleBoxUnitFt) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleBoxUnitFt) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleBoxUnitFt) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleBoxUnitFt) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleBoxUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleBoxUnitFt) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleBoxUnitKm Incomplete
func (c GeosearchCircleBoxUnitKm) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleBoxUnitKm) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleBoxUnitKm) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleBoxUnitKm) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleBoxUnitKm) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleBoxUnitKm) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleBoxUnitKm) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleBoxUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleBoxUnitKm) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleBoxUnitM Incomplete
func (c GeosearchCircleBoxUnitM) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleBoxUnitM) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleBoxUnitM) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleBoxUnitM) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleBoxUnitM) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleBoxUnitM) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleBoxUnitM) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleBoxUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleBoxUnitM) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleBoxUnitMi Incomplete
func (c GeosearchCircleBoxUnitMi) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleBoxUnitMi) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleBoxUnitMi) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleBoxUnitMi) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleBoxUnitMi) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleBoxUnitMi) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleBoxUnitMi) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleBoxUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleBoxUnitMi) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleCircleByradius Incomplete
func (c GeosearchCircleCircleByradius) M() GeosearchCircleCircleUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeosearchCircleCircleUnitM)(c)
}
func (c GeosearchCircleCircleByradius) Km() GeosearchCircleCircleUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeosearchCircleCircleUnitKm)(c)
}
func (c GeosearchCircleCircleByradius) Ft() GeosearchCircleCircleUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeosearchCircleCircleUnitFt)(c)
}
func (c GeosearchCircleCircleByradius) Mi() GeosearchCircleCircleUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeosearchCircleCircleUnitMi)(c)
}
type GeosearchCircleCircleUnitFt Incomplete
func (c GeosearchCircleCircleUnitFt) Bybox(width float64) GeosearchCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchCircleBoxBybox)(c)
}
func (c GeosearchCircleCircleUnitFt) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleCircleUnitFt) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleCircleUnitFt) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleCircleUnitFt) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleCircleUnitFt) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleCircleUnitFt) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleCircleUnitFt) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleCircleUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleCircleUnitFt) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleCircleUnitKm Incomplete
func (c GeosearchCircleCircleUnitKm) Bybox(width float64) GeosearchCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchCircleBoxBybox)(c)
}
func (c GeosearchCircleCircleUnitKm) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleCircleUnitKm) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleCircleUnitKm) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleCircleUnitKm) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleCircleUnitKm) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleCircleUnitKm) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleCircleUnitKm) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleCircleUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleCircleUnitKm) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleCircleUnitM Incomplete
func (c GeosearchCircleCircleUnitM) Bybox(width float64) GeosearchCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchCircleBoxBybox)(c)
}
func (c GeosearchCircleCircleUnitM) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleCircleUnitM) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleCircleUnitM) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleCircleUnitM) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleCircleUnitM) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleCircleUnitM) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleCircleUnitM) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleCircleUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleCircleUnitM) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCircleCircleUnitMi Incomplete
func (c GeosearchCircleCircleUnitMi) Bybox(width float64) GeosearchCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchCircleBoxBybox)(c)
}
func (c GeosearchCircleCircleUnitMi) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
func (c GeosearchCircleCircleUnitMi) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCircleCircleUnitMi) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCircleCircleUnitMi) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCircleCircleUnitMi) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCircleCircleUnitMi) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCircleCircleUnitMi) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCircleCircleUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCircleCircleUnitMi) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCirclePolygonNumVertices Incomplete
func (c GeosearchCirclePolygonNumVertices) Longitude(longitude float64) GeosearchCirclePolygonVerticesLongitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
return (GeosearchCirclePolygonVerticesLongitude)(c)
}
type GeosearchCirclePolygonVerticesLatitude Incomplete
func (c GeosearchCirclePolygonVerticesLatitude) Longitude(longitude float64) GeosearchCirclePolygonVerticesLongitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
return (GeosearchCirclePolygonVerticesLongitude)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Asc() GeosearchOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchOrderAsc)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Desc() GeosearchOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchOrderDesc)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCirclePolygonVerticesLatitude) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCirclePolygonVerticesLatitude) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCirclePolygonVerticesLongitude Incomplete
func (c GeosearchCirclePolygonVerticesLongitude) Latitude(latitude float64) GeosearchCirclePolygonVerticesLatitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeosearchCirclePolygonVerticesLatitude)(c)
}
type GeosearchCountAny Incomplete
func (c GeosearchCountAny) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCountAny) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCountAny) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCountAny) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCountAny) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchCountCount Incomplete
func (c GeosearchCountCount) Any() GeosearchCountAny {
c.cs.s = append(c.cs.s, "ANY")
return (GeosearchCountAny)(c)
}
func (c GeosearchCountCount) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchCountCount) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchCountCount) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchCountCount) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchFrommemberFromlonlat Incomplete
func (c GeosearchFrommemberFromlonlat) Byradius(radius float64) GeosearchCircleCircleByradius {
c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
return (GeosearchCircleCircleByradius)(c)
}
func (c GeosearchFrommemberFromlonlat) Bybox(width float64) GeosearchCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchCircleBoxBybox)(c)
}
func (c GeosearchFrommemberFromlonlat) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
type GeosearchFrommemberFrommember Incomplete
func (c GeosearchFrommemberFrommember) Fromlonlat(longitude float64, latitude float64) GeosearchFrommemberFromlonlat {
c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeosearchFrommemberFromlonlat)(c)
}
func (c GeosearchFrommemberFrommember) Byradius(radius float64) GeosearchCircleCircleByradius {
c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
return (GeosearchCircleCircleByradius)(c)
}
func (c GeosearchFrommemberFrommember) Bybox(width float64) GeosearchCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchCircleBoxBybox)(c)
}
func (c GeosearchFrommemberFrommember) NumVertices(numVertices int64) GeosearchCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchCirclePolygonNumVertices)(c)
}
type GeosearchKey Incomplete
func (c GeosearchKey) Frommember(member string) GeosearchFrommemberFrommember {
c.cs.s = append(c.cs.s, "FROMMEMBER", member)
return (GeosearchFrommemberFrommember)(c)
}
func (c GeosearchKey) Fromlonlat(longitude float64, latitude float64) GeosearchFrommemberFromlonlat {
c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeosearchFrommemberFromlonlat)(c)
}
type GeosearchOrderAsc Incomplete
func (c GeosearchOrderAsc) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchOrderAsc) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchOrderAsc) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchOrderAsc) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchOrderAsc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchOrderAsc) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchOrderDesc Incomplete
func (c GeosearchOrderDesc) Count(count int64) GeosearchCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchCountCount)(c)
}
func (c GeosearchOrderDesc) Withcoord() GeosearchWithcoord {
c.cs.s = append(c.cs.s, "WITHCOORD")
return (GeosearchWithcoord)(c)
}
func (c GeosearchOrderDesc) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchOrderDesc) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchOrderDesc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchOrderDesc) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchWithcoord Incomplete
func (c GeosearchWithcoord) Withdist() GeosearchWithdist {
c.cs.s = append(c.cs.s, "WITHDIST")
return (GeosearchWithdist)(c)
}
func (c GeosearchWithcoord) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchWithcoord) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchWithcoord) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchWithdist Incomplete
func (c GeosearchWithdist) Withhash() GeosearchWithhash {
c.cs.s = append(c.cs.s, "WITHHASH")
return (GeosearchWithhash)(c)
}
func (c GeosearchWithdist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchWithdist) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchWithhash Incomplete
func (c GeosearchWithhash) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
func (c GeosearchWithhash) Cache() Cacheable {
c.cs.Build()
return Cacheable{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type Geosearchstore Incomplete
func (b Builder) Geosearchstore() (c Geosearchstore) {
c = Geosearchstore{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "GEOSEARCHSTORE")
return c
}
func (c Geosearchstore) Destination(destination string) GeosearchstoreDestination {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(destination)
} else {
c.ks = check(c.ks, slot(destination))
}
c.cs.s = append(c.cs.s, destination)
return (GeosearchstoreDestination)(c)
}
type GeosearchstoreCircleBoxBybox Incomplete
func (c GeosearchstoreCircleBoxBybox) Height(height float64) GeosearchstoreCircleBoxHeight {
c.cs.s = append(c.cs.s, strconv.FormatFloat(height, 'f', -1, 64))
return (GeosearchstoreCircleBoxHeight)(c)
}
type GeosearchstoreCircleBoxHeight Incomplete
func (c GeosearchstoreCircleBoxHeight) M() GeosearchstoreCircleBoxUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeosearchstoreCircleBoxUnitM)(c)
}
func (c GeosearchstoreCircleBoxHeight) Km() GeosearchstoreCircleBoxUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeosearchstoreCircleBoxUnitKm)(c)
}
func (c GeosearchstoreCircleBoxHeight) Ft() GeosearchstoreCircleBoxUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeosearchstoreCircleBoxUnitFt)(c)
}
func (c GeosearchstoreCircleBoxHeight) Mi() GeosearchstoreCircleBoxUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeosearchstoreCircleBoxUnitMi)(c)
}
type GeosearchstoreCircleBoxUnitFt Incomplete
func (c GeosearchstoreCircleBoxUnitFt) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleBoxUnitFt) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleBoxUnitFt) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleBoxUnitFt) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleBoxUnitFt) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleBoxUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleBoxUnitKm Incomplete
func (c GeosearchstoreCircleBoxUnitKm) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleBoxUnitKm) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleBoxUnitKm) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleBoxUnitKm) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleBoxUnitKm) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleBoxUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleBoxUnitM Incomplete
func (c GeosearchstoreCircleBoxUnitM) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleBoxUnitM) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleBoxUnitM) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleBoxUnitM) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleBoxUnitM) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleBoxUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleBoxUnitMi Incomplete
func (c GeosearchstoreCircleBoxUnitMi) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleBoxUnitMi) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleBoxUnitMi) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleBoxUnitMi) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleBoxUnitMi) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleBoxUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleCircleByradius Incomplete
func (c GeosearchstoreCircleCircleByradius) M() GeosearchstoreCircleCircleUnitM {
c.cs.s = append(c.cs.s, "m")
return (GeosearchstoreCircleCircleUnitM)(c)
}
func (c GeosearchstoreCircleCircleByradius) Km() GeosearchstoreCircleCircleUnitKm {
c.cs.s = append(c.cs.s, "km")
return (GeosearchstoreCircleCircleUnitKm)(c)
}
func (c GeosearchstoreCircleCircleByradius) Ft() GeosearchstoreCircleCircleUnitFt {
c.cs.s = append(c.cs.s, "ft")
return (GeosearchstoreCircleCircleUnitFt)(c)
}
func (c GeosearchstoreCircleCircleByradius) Mi() GeosearchstoreCircleCircleUnitMi {
c.cs.s = append(c.cs.s, "mi")
return (GeosearchstoreCircleCircleUnitMi)(c)
}
type GeosearchstoreCircleCircleUnitFt Incomplete
func (c GeosearchstoreCircleCircleUnitFt) Bybox(width float64) GeosearchstoreCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchstoreCircleBoxBybox)(c)
}
func (c GeosearchstoreCircleCircleUnitFt) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleCircleUnitFt) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleCircleUnitFt) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleCircleUnitFt) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleCircleUnitFt) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleCircleUnitFt) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleCircleUnitKm Incomplete
func (c GeosearchstoreCircleCircleUnitKm) Bybox(width float64) GeosearchstoreCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchstoreCircleBoxBybox)(c)
}
func (c GeosearchstoreCircleCircleUnitKm) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleCircleUnitKm) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleCircleUnitKm) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleCircleUnitKm) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleCircleUnitKm) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleCircleUnitKm) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleCircleUnitM Incomplete
func (c GeosearchstoreCircleCircleUnitM) Bybox(width float64) GeosearchstoreCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchstoreCircleBoxBybox)(c)
}
func (c GeosearchstoreCircleCircleUnitM) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleCircleUnitM) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleCircleUnitM) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleCircleUnitM) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleCircleUnitM) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleCircleUnitM) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCircleCircleUnitMi Incomplete
func (c GeosearchstoreCircleCircleUnitMi) Bybox(width float64) GeosearchstoreCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchstoreCircleBoxBybox)(c)
}
func (c GeosearchstoreCircleCircleUnitMi) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
func (c GeosearchstoreCircleCircleUnitMi) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCircleCircleUnitMi) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCircleCircleUnitMi) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCircleCircleUnitMi) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCircleCircleUnitMi) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCirclePolygonNumVertices Incomplete
func (c GeosearchstoreCirclePolygonNumVertices) Longitude(longitude float64) GeosearchstoreCirclePolygonVerticesLongitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
return (GeosearchstoreCirclePolygonVerticesLongitude)(c)
}
type GeosearchstoreCirclePolygonVerticesLatitude Incomplete
func (c GeosearchstoreCirclePolygonVerticesLatitude) Longitude(longitude float64) GeosearchstoreCirclePolygonVerticesLongitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(longitude, 'f', -1, 64))
return (GeosearchstoreCirclePolygonVerticesLongitude)(c)
}
func (c GeosearchstoreCirclePolygonVerticesLatitude) Asc() GeosearchstoreOrderAsc {
c.cs.s = append(c.cs.s, "ASC")
return (GeosearchstoreOrderAsc)(c)
}
func (c GeosearchstoreCirclePolygonVerticesLatitude) Desc() GeosearchstoreOrderDesc {
c.cs.s = append(c.cs.s, "DESC")
return (GeosearchstoreOrderDesc)(c)
}
func (c GeosearchstoreCirclePolygonVerticesLatitude) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreCirclePolygonVerticesLatitude) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCirclePolygonVerticesLatitude) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCirclePolygonVerticesLongitude Incomplete
func (c GeosearchstoreCirclePolygonVerticesLongitude) Latitude(latitude float64) GeosearchstoreCirclePolygonVerticesLatitude {
c.cs.s = append(c.cs.s, strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeosearchstoreCirclePolygonVerticesLatitude)(c)
}
type GeosearchstoreCountAny Incomplete
func (c GeosearchstoreCountAny) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCountAny) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreCountCount Incomplete
func (c GeosearchstoreCountCount) Any() GeosearchstoreCountAny {
c.cs.s = append(c.cs.s, "ANY")
return (GeosearchstoreCountAny)(c)
}
func (c GeosearchstoreCountCount) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreCountCount) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreDestination Incomplete
func (c GeosearchstoreDestination) Source(source string) GeosearchstoreSource {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(source)
} else {
c.ks = check(c.ks, slot(source))
}
c.cs.s = append(c.cs.s, source)
return (GeosearchstoreSource)(c)
}
type GeosearchstoreFrommemberFromlonlat Incomplete
func (c GeosearchstoreFrommemberFromlonlat) Byradius(radius float64) GeosearchstoreCircleCircleByradius {
c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
return (GeosearchstoreCircleCircleByradius)(c)
}
func (c GeosearchstoreFrommemberFromlonlat) Bybox(width float64) GeosearchstoreCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchstoreCircleBoxBybox)(c)
}
func (c GeosearchstoreFrommemberFromlonlat) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
type GeosearchstoreFrommemberFrommember Incomplete
func (c GeosearchstoreFrommemberFrommember) Fromlonlat(longitude float64, latitude float64) GeosearchstoreFrommemberFromlonlat {
c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeosearchstoreFrommemberFromlonlat)(c)
}
func (c GeosearchstoreFrommemberFrommember) Byradius(radius float64) GeosearchstoreCircleCircleByradius {
c.cs.s = append(c.cs.s, "BYRADIUS", strconv.FormatFloat(radius, 'f', -1, 64))
return (GeosearchstoreCircleCircleByradius)(c)
}
func (c GeosearchstoreFrommemberFrommember) Bybox(width float64) GeosearchstoreCircleBoxBybox {
c.cs.s = append(c.cs.s, "BYBOX", strconv.FormatFloat(width, 'f', -1, 64))
return (GeosearchstoreCircleBoxBybox)(c)
}
func (c GeosearchstoreFrommemberFrommember) NumVertices(numVertices int64) GeosearchstoreCirclePolygonNumVertices {
c.cs.s = append(c.cs.s, "BYPOLYGON", strconv.FormatInt(numVertices, 10))
return (GeosearchstoreCirclePolygonNumVertices)(c)
}
type GeosearchstoreOrderAsc Incomplete
func (c GeosearchstoreOrderAsc) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreOrderAsc) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreOrderAsc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreOrderDesc Incomplete
func (c GeosearchstoreOrderDesc) Count(count int64) GeosearchstoreCountCount {
c.cs.s = append(c.cs.s, "COUNT", strconv.FormatInt(count, 10))
return (GeosearchstoreCountCount)(c)
}
func (c GeosearchstoreOrderDesc) Storedist() GeosearchstoreStoredist {
c.cs.s = append(c.cs.s, "STOREDIST")
return (GeosearchstoreStoredist)(c)
}
func (c GeosearchstoreOrderDesc) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type GeosearchstoreSource Incomplete
func (c GeosearchstoreSource) Frommember(member string) GeosearchstoreFrommemberFrommember {
c.cs.s = append(c.cs.s, "FROMMEMBER", member)
return (GeosearchstoreFrommemberFrommember)(c)
}
func (c GeosearchstoreSource) Fromlonlat(longitude float64, latitude float64) GeosearchstoreFrommemberFromlonlat {
c.cs.s = append(c.cs.s, "FROMLONLAT", strconv.FormatFloat(longitude, 'f', -1, 64), strconv.FormatFloat(latitude, 'f', -1, 64))
return (GeosearchstoreFrommemberFromlonlat)(c)
}
type GeosearchstoreStoredist Incomplete
func (c GeosearchstoreStoredist) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
Reference in New Issue View Git Blame Copy Permalink