claude/mattermost-community-enterprise
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
302a074c8e
mattermost-community-enterp.../vendor/github.com/redis/rueidis/internal/cmds/gen_tdigest.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

558 lines
13 KiB
Go
Raw Blame History

// Code generated DO NOT EDIT
package cmds
import "strconv"
type TdigestAdd Incomplete
func (b Builder) TdigestAdd() (c TdigestAdd) {
c = TdigestAdd{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.ADD")
return c
}
func (c TdigestAdd) Key(key string) TdigestAddKey {
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 (TdigestAddKey)(c)
}
type TdigestAddKey Incomplete
func (c TdigestAddKey) Value(value float64) TdigestAddValuesValue {
c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
return (TdigestAddValuesValue)(c)
}
type TdigestAddValuesValue Incomplete
func (c TdigestAddValuesValue) Value(value float64) TdigestAddValuesValue {
c.cs.s = append(c.cs.s, strconv.FormatFloat(value, 'f', -1, 64))
return c
}
func (c TdigestAddValuesValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestByrank Incomplete
func (b Builder) TdigestByrank() (c TdigestByrank) {
c = TdigestByrank{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.BYRANK")
return c
}
func (c TdigestByrank) Key(key string) TdigestByrankKey {
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 (TdigestByrankKey)(c)
}
type TdigestByrankKey Incomplete
func (c TdigestByrankKey) Rank(rank ...float64) TdigestByrankRank {
for _, n := range rank {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return (TdigestByrankRank)(c)
}
type TdigestByrankRank Incomplete
func (c TdigestByrankRank) Rank(rank ...float64) TdigestByrankRank {
for _, n := range rank {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return c
}
func (c TdigestByrankRank) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestByrevrank Incomplete
func (b Builder) TdigestByrevrank() (c TdigestByrevrank) {
c = TdigestByrevrank{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.BYREVRANK")
return c
}
func (c TdigestByrevrank) Key(key string) TdigestByrevrankKey {
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 (TdigestByrevrankKey)(c)
}
type TdigestByrevrankKey Incomplete
func (c TdigestByrevrankKey) ReverseRank(reverseRank ...float64) TdigestByrevrankReverseRank {
for _, n := range reverseRank {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return (TdigestByrevrankReverseRank)(c)
}
type TdigestByrevrankReverseRank Incomplete
func (c TdigestByrevrankReverseRank) ReverseRank(reverseRank ...float64) TdigestByrevrankReverseRank {
for _, n := range reverseRank {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return c
}
func (c TdigestByrevrankReverseRank) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestCdf Incomplete
func (b Builder) TdigestCdf() (c TdigestCdf) {
c = TdigestCdf{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.CDF")
return c
}
func (c TdigestCdf) Key(key string) TdigestCdfKey {
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 (TdigestCdfKey)(c)
}
type TdigestCdfKey Incomplete
func (c TdigestCdfKey) Value(value ...float64) TdigestCdfValue {
for _, n := range value {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return (TdigestCdfValue)(c)
}
type TdigestCdfValue Incomplete
func (c TdigestCdfValue) Value(value ...float64) TdigestCdfValue {
for _, n := range value {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return c
}
func (c TdigestCdfValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestCreate Incomplete
func (b Builder) TdigestCreate() (c TdigestCreate) {
c = TdigestCreate{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.CREATE")
return c
}
func (c TdigestCreate) Key(key string) TdigestCreateKey {
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 (TdigestCreateKey)(c)
}
type TdigestCreateCompression Incomplete
func (c TdigestCreateCompression) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestCreateKey Incomplete
func (c TdigestCreateKey) Compression(compression int64) TdigestCreateCompression {
c.cs.s = append(c.cs.s, "COMPRESSION", strconv.FormatInt(compression, 10))
return (TdigestCreateCompression)(c)
}
func (c TdigestCreateKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestInfo Incomplete
func (b Builder) TdigestInfo() (c TdigestInfo) {
c = TdigestInfo{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.INFO")
return c
}
func (c TdigestInfo) Key(key string) TdigestInfoKey {
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 (TdigestInfoKey)(c)
}
type TdigestInfoKey Incomplete
func (c TdigestInfoKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestMax Incomplete
func (b Builder) TdigestMax() (c TdigestMax) {
c = TdigestMax{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.MAX")
return c
}
func (c TdigestMax) Key(key string) TdigestMaxKey {
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 (TdigestMaxKey)(c)
}
type TdigestMaxKey Incomplete
func (c TdigestMaxKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestMerge Incomplete
func (b Builder) TdigestMerge() (c TdigestMerge) {
c = TdigestMerge{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.MERGE")
return c
}
func (c TdigestMerge) DestinationKey(destinationKey string) TdigestMergeDestinationKey {
if c.ks&NoSlot == NoSlot {
c.ks = NoSlot | slot(destinationKey)
} else {
c.ks = check(c.ks, slot(destinationKey))
}
c.cs.s = append(c.cs.s, destinationKey)
return (TdigestMergeDestinationKey)(c)
}
type TdigestMergeConfigCompression Incomplete
func (c TdigestMergeConfigCompression) Override() TdigestMergeOverride {
c.cs.s = append(c.cs.s, "OVERRIDE")
return (TdigestMergeOverride)(c)
}
func (c TdigestMergeConfigCompression) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestMergeDestinationKey Incomplete
func (c TdigestMergeDestinationKey) Numkeys(numkeys int64) TdigestMergeNumkeys {
c.cs.s = append(c.cs.s, strconv.FormatInt(numkeys, 10))
return (TdigestMergeNumkeys)(c)
}
type TdigestMergeNumkeys Incomplete
func (c TdigestMergeNumkeys) SourceKey(sourceKey ...string) TdigestMergeSourceKey {
if c.ks&NoSlot == NoSlot {
for _, k := range sourceKey {
c.ks = NoSlot | slot(k)
break
}
} else {
for _, k := range sourceKey {
c.ks = check(c.ks, slot(k))
}
}
c.cs.s = append(c.cs.s, sourceKey...)
return (TdigestMergeSourceKey)(c)
}
type TdigestMergeOverride Incomplete
func (c TdigestMergeOverride) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestMergeSourceKey Incomplete
func (c TdigestMergeSourceKey) SourceKey(sourceKey ...string) TdigestMergeSourceKey {
if c.ks&NoSlot == NoSlot {
for _, k := range sourceKey {
c.ks = NoSlot | slot(k)
break
}
} else {
for _, k := range sourceKey {
c.ks = check(c.ks, slot(k))
}
}
c.cs.s = append(c.cs.s, sourceKey...)
return c
}
func (c TdigestMergeSourceKey) Compression(compression int64) TdigestMergeConfigCompression {
c.cs.s = append(c.cs.s, "COMPRESSION", strconv.FormatInt(compression, 10))
return (TdigestMergeConfigCompression)(c)
}
func (c TdigestMergeSourceKey) Override() TdigestMergeOverride {
c.cs.s = append(c.cs.s, "OVERRIDE")
return (TdigestMergeOverride)(c)
}
func (c TdigestMergeSourceKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestMin Incomplete
func (b Builder) TdigestMin() (c TdigestMin) {
c = TdigestMin{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.MIN")
return c
}
func (c TdigestMin) Key(key string) TdigestMinKey {
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 (TdigestMinKey)(c)
}
type TdigestMinKey Incomplete
func (c TdigestMinKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestQuantile Incomplete
func (b Builder) TdigestQuantile() (c TdigestQuantile) {
c = TdigestQuantile{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.QUANTILE")
return c
}
func (c TdigestQuantile) Key(key string) TdigestQuantileKey {
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 (TdigestQuantileKey)(c)
}
type TdigestQuantileKey Incomplete
func (c TdigestQuantileKey) Quantile(quantile ...float64) TdigestQuantileQuantile {
for _, n := range quantile {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return (TdigestQuantileQuantile)(c)
}
type TdigestQuantileQuantile Incomplete
func (c TdigestQuantileQuantile) Quantile(quantile ...float64) TdigestQuantileQuantile {
for _, n := range quantile {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return c
}
func (c TdigestQuantileQuantile) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestRank Incomplete
func (b Builder) TdigestRank() (c TdigestRank) {
c = TdigestRank{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.RANK")
return c
}
func (c TdigestRank) Key(key string) TdigestRankKey {
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 (TdigestRankKey)(c)
}
type TdigestRankKey Incomplete
func (c TdigestRankKey) Value(value ...float64) TdigestRankValue {
for _, n := range value {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return (TdigestRankValue)(c)
}
type TdigestRankValue Incomplete
func (c TdigestRankValue) Value(value ...float64) TdigestRankValue {
for _, n := range value {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return c
}
func (c TdigestRankValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestReset Incomplete
func (b Builder) TdigestReset() (c TdigestReset) {
c = TdigestReset{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.RESET")
return c
}
func (c TdigestReset) Key(key string) TdigestResetKey {
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 (TdigestResetKey)(c)
}
type TdigestResetKey Incomplete
func (c TdigestResetKey) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestRevrank Incomplete
func (b Builder) TdigestRevrank() (c TdigestRevrank) {
c = TdigestRevrank{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.REVRANK")
return c
}
func (c TdigestRevrank) Key(key string) TdigestRevrankKey {
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 (TdigestRevrankKey)(c)
}
type TdigestRevrankKey Incomplete
func (c TdigestRevrankKey) Value(value ...float64) TdigestRevrankValue {
for _, n := range value {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return (TdigestRevrankValue)(c)
}
type TdigestRevrankValue Incomplete
func (c TdigestRevrankValue) Value(value ...float64) TdigestRevrankValue {
for _, n := range value {
c.cs.s = append(c.cs.s, strconv.FormatFloat(n, 'f', -1, 64))
}
return c
}
func (c TdigestRevrankValue) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestTrimmedMean Incomplete
func (b Builder) TdigestTrimmedMean() (c TdigestTrimmedMean) {
c = TdigestTrimmedMean{cs: get(), ks: b.ks}
c.cs.s = append(c.cs.s, "TDIGEST.TRIMMED_MEAN")
return c
}
func (c TdigestTrimmedMean) Key(key string) TdigestTrimmedMeanKey {
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 (TdigestTrimmedMeanKey)(c)
}
type TdigestTrimmedMeanHighCutQuantile Incomplete
func (c TdigestTrimmedMeanHighCutQuantile) Build() Completed {
c.cs.Build()
return Completed{cs: c.cs, cf: uint16(c.cf), ks: c.ks}
}
type TdigestTrimmedMeanKey Incomplete
func (c TdigestTrimmedMeanKey) LowCutQuantile(lowCutQuantile float64) TdigestTrimmedMeanLowCutQuantile {
c.cs.s = append(c.cs.s, strconv.FormatFloat(lowCutQuantile, 'f', -1, 64))
return (TdigestTrimmedMeanLowCutQuantile)(c)
}
type TdigestTrimmedMeanLowCutQuantile Incomplete
func (c TdigestTrimmedMeanLowCutQuantile) HighCutQuantile(highCutQuantile float64) TdigestTrimmedMeanHighCutQuantile {
c.cs.s = append(c.cs.s, strconv.FormatFloat(highCutQuantile, 'f', -1, 64))
return (TdigestTrimmedMeanHighCutQuantile)(c)
}
Reference in New Issue View Git Blame Copy Permalink