├── .gitignore ├── .gitmodules ├── LICENSE ├── Makefile ├── README.md ├── VERSION ├── client_wire.go ├── examples └── example_ping │ └── main.go ├── go.mod ├── go.sum ├── internal ├── protobuf_wire.go ├── tcp_wire.go ├── tcp_wire_test.go └── wire.go ├── main.go ├── main_test.go ├── mock └── conn.go ├── retrier.go ├── server_wire.go ├── wal └── wal.pb.go └── wire ├── cmd.pb.go ├── error.go └── res.pb.go /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | -------------------------------------------------------------------------------- /.gitmodules: -------------------------------------------------------------------------------- 1 | [submodule "protos"] 2 | path = protos 3 | url = git@github.com:dicedb/dicedb-protos.git 4 | branch = master 5 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | BSD 3-Clause License 2 | 3 | Copyright (c) 2022-present, DiceDB contributors 4 | 5 | Redistribution and use in source and binary forms, with or without 6 | modification, are permitted provided that the following conditions are met: 7 | 8 | 1. Redistributions of source code must retain the above copyright notice, this 9 | list of conditions and the following disclaimer. 10 | 11 | 2. Redistributions in binary form must reproduce the above copyright notice, 12 | this list of conditions and the following disclaimer in the documentation 13 | and/or other materials provided with the distribution. 14 | 15 | 3. Neither the name of the copyright holder nor the names of its 16 | contributors may be used to endorse or promote products derived from 17 | this software without specific prior written permission. 18 | 19 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 22 | DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE 23 | FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 | DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 25 | SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 26 | CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 27 | OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 28 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 29 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | GOLANGCI_LINT_VERSION := 1.60.1 2 | 3 | VERSION := $(shell cat VERSION) 4 | 5 | lint: 6 | gofmt -w . 7 | golangci-lint run ./... 8 | 9 | generate: 10 | protoc --go_out=. --go-grpc_out=. protos/*.proto 11 | protoc --go_out=. --go-grpc_out=. protos/wal/*.proto 12 | 13 | test: 14 | go test ./... 15 | 16 | release: 17 | git tag -a $(VERSION) -m "release $(VERSION)" 18 | git push origin $(VERSION) 19 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | dicedb-go 2 | === 3 | 4 | Go client for [DiceDB](https://github.com/dicedb/dice). 5 | 6 | ## Installations 7 | 8 | ```bash 9 | $ go get github.com/dicedb/dicedb-go@v1.0.9 10 | ``` 11 | 12 | ## Get Started 13 | 14 | To start using DiceDB with Golang, you can follow the example 15 | tutorials present in the [dice/examples](https://github.com/DiceDB/dice/tree/master/examples) directory. 16 | -------------------------------------------------------------------------------- /VERSION: -------------------------------------------------------------------------------- 1 | v1.0.11 -------------------------------------------------------------------------------- /client_wire.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2022-present, DiceDB contributors 2 | // All rights reserved. Licensed under the BSD 3-Clause License. See LICENSE file in the project root for full license information. 3 | 4 | package dicedb 5 | 6 | import ( 7 | "fmt" 8 | "net" 9 | "time" 10 | 11 | "github.com/dicedb/dicedb-go/internal" 12 | "github.com/dicedb/dicedb-go/wire" 13 | ) 14 | 15 | type ClientWire struct { 16 | *internal.ProtobufTCPWire 17 | } 18 | 19 | func NewClientWire(maxMsgSize int, host string, port int) (*ClientWire, *wire.WireError) { 20 | addr := fmt.Sprintf("%s:%d", host, port) 21 | conn, err := net.DialTimeout("tcp", addr, 5*time.Second) 22 | if err != nil { 23 | return nil, &wire.WireError{Kind: wire.NotEstablished, Cause: err} 24 | } 25 | w := &ClientWire{ 26 | ProtobufTCPWire: internal.NewProtobufTCPWire(maxMsgSize, conn), 27 | } 28 | 29 | return w, nil 30 | } 31 | 32 | func (cw *ClientWire) Send(cmd *wire.Command) *wire.WireError { 33 | return cw.ProtobufTCPWire.Send(cmd) 34 | } 35 | 36 | func (cw *ClientWire) Receive() (*wire.Result, *wire.WireError) { 37 | resp := &wire.Result{} 38 | err := cw.ProtobufTCPWire.Receive(resp) 39 | 40 | return resp, err 41 | } 42 | 43 | func (cw *ClientWire) Close() { 44 | cw.ProtobufTCPWire.Close() 45 | } 46 | -------------------------------------------------------------------------------- /examples/example_ping/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | 6 | "github.com/dicedb/dicedb-go" 7 | "github.com/dicedb/dicedb-go/wire" 8 | ) 9 | 10 | func main() { 11 | client, err := dicedb.NewClient("localhost", 7379) 12 | if err != nil { 13 | fmt.Println(err) 14 | } 15 | defer client.Close() 16 | 17 | resp := client.Fire(&wire.Command{Cmd: "PING"}) 18 | fmt.Println(resp) 19 | } 20 | -------------------------------------------------------------------------------- /go.mod: -------------------------------------------------------------------------------- 1 | module github.com/dicedb/dicedb-go 2 | 3 | go 1.24.0 4 | 5 | require google.golang.org/protobuf v1.36.5 6 | 7 | require ( 8 | github.com/google/uuid v1.6.0 9 | go.uber.org/mock v0.5.1 10 | ) 11 | -------------------------------------------------------------------------------- /go.sum: -------------------------------------------------------------------------------- 1 | github.com/google/go-cmp v0.5.5 h1:Khx7svrCpmxxtHBq5j2mp/xVjsi8hQMfNLvJFAlrGgU= 2 | github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= 3 | github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= 4 | github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= 5 | go.uber.org/mock v0.5.1 h1:ASgazW/qBmR+A32MYFDB6E2POoTgOwT509VP0CT/fjs= 6 | go.uber.org/mock v0.5.1/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= 7 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4= 8 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 9 | google.golang.org/protobuf v1.36.5 h1:tPhr+woSbjfYvY6/GPufUoYizxw1cF/yFoxJ2fmpwlM= 10 | google.golang.org/protobuf v1.36.5/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= 11 | -------------------------------------------------------------------------------- /internal/protobuf_wire.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2022-present, DiceDB contributors 2 | // All rights reserved. Licensed under the BSD 3-Clause License. See LICENSE file in the project root for full license information. 3 | 4 | package internal 5 | 6 | import ( 7 | "github.com/dicedb/dicedb-go/wire" 8 | "net" 9 | 10 | "google.golang.org/protobuf/proto" 11 | ) 12 | 13 | type ProtobufTCPWire struct { 14 | tcpWire Wire 15 | } 16 | 17 | func NewProtobufTCPWire(maxMsgSize int, conn net.Conn) *ProtobufTCPWire { 18 | return &ProtobufTCPWire{ 19 | tcpWire: NewTCPWire(maxMsgSize, conn), 20 | } 21 | } 22 | 23 | func (w *ProtobufTCPWire) Send(msg proto.Message) *wire.WireError { 24 | buffer, err := proto.Marshal(msg) 25 | if err != nil { 26 | w.tcpWire.Close() 27 | return &wire.WireError{Kind: wire.CorruptMessage, Cause: err} 28 | } 29 | 30 | return w.tcpWire.Send(buffer) 31 | } 32 | 33 | func (w *ProtobufTCPWire) Receive(dst proto.Message) *wire.WireError { 34 | buffer, err := w.tcpWire.Receive() 35 | if err != nil { 36 | return err 37 | } 38 | 39 | uerr := proto.Unmarshal(buffer, dst) 40 | if uerr != nil { 41 | w.tcpWire.Close() 42 | return &wire.WireError{Kind: wire.CorruptMessage, Cause: uerr} 43 | } 44 | 45 | return nil 46 | } 47 | 48 | func (w *ProtobufTCPWire) Close() { 49 | w.tcpWire.Close() 50 | } 51 | -------------------------------------------------------------------------------- /internal/tcp_wire.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2022-present, DiceDB contributors 2 | // All rights reserved. Licensed under the BSD 3-Clause License. See LICENSE file in the project root for full license information. 3 | 4 | package internal 5 | 6 | import ( 7 | "bufio" 8 | "encoding/binary" 9 | "errors" 10 | "fmt" 11 | "github.com/dicedb/dicedb-go/wire" 12 | "io" 13 | "log/slog" 14 | "net" 15 | "strings" 16 | "sync" 17 | "time" 18 | ) 19 | 20 | const prefixSize = 4 // bytes 21 | 22 | type Status int 23 | 24 | const ( 25 | Open Status = 1 26 | Closed Status = 2 27 | ) 28 | 29 | type TCPWire struct { 30 | status Status 31 | maxMsgSize int 32 | readMu sync.Mutex 33 | reader *bufio.Reader 34 | writeMu sync.Mutex 35 | conn net.Conn 36 | } 37 | 38 | func NewTCPWire(maxMsgSize int, conn net.Conn) *TCPWire { 39 | return &TCPWire{ 40 | status: Open, 41 | maxMsgSize: maxMsgSize, 42 | conn: conn, 43 | reader: bufio.NewReader(conn), 44 | } 45 | } 46 | 47 | func (w *TCPWire) Send(msg []byte) *wire.WireError { 48 | w.writeMu.Lock() 49 | defer w.writeMu.Unlock() 50 | 51 | if w.status == Closed { 52 | return &wire.WireError{Kind: wire.Terminated, Cause: errors.New("trying to use closed wire")} 53 | } 54 | 55 | size := len(msg) 56 | buffer := make([]byte, prefixSize+size) 57 | 58 | prefix(size, buffer) 59 | copy(buffer[prefixSize:], msg) 60 | 61 | return w.write(buffer) 62 | } 63 | 64 | func (w *TCPWire) Receive() ([]byte, *wire.WireError) { 65 | w.readMu.Lock() 66 | defer w.readMu.Unlock() 67 | 68 | size, err := w.readPrefix() 69 | if err != nil { 70 | return nil, err 71 | } 72 | 73 | if size <= 0 { 74 | w.Close() 75 | return nil, &wire.WireError{ 76 | Kind: wire.CorruptMessage, 77 | Cause: fmt.Errorf("invalid message size: %d", size), 78 | } 79 | } 80 | 81 | if size > uint32(w.maxMsgSize) { 82 | w.Close() 83 | return nil, &wire.WireError{ 84 | Kind: wire.CorruptMessage, 85 | Cause: fmt.Errorf("message too large: %d bytes (max: %d)", size, w.maxMsgSize), 86 | } 87 | } 88 | 89 | buffer, err := w.readMessage(size) 90 | if err != nil { 91 | return nil, err 92 | } 93 | 94 | return buffer, nil 95 | } 96 | 97 | func (w *TCPWire) Close() { 98 | if w.status == Closed { 99 | return 100 | } 101 | 102 | w.status = Closed 103 | err := w.conn.Close() 104 | if err != nil { 105 | slog.Warn("error closing network connection", "error", err) 106 | 107 | return 108 | } 109 | } 110 | 111 | func (w *TCPWire) readPrefix() (uint32, *wire.WireError) { 112 | buffer := make([]byte, prefixSize) 113 | delay := 5 * time.Millisecond 114 | const maxRetries = 5 115 | 116 | var lastErr error 117 | for attempt := 0; attempt < maxRetries; attempt++ { 118 | _, err := io.ReadFull(w.reader, buffer) 119 | if err == nil { 120 | return binary.BigEndian.Uint32(buffer), nil 121 | } 122 | 123 | lastErr = err 124 | 125 | // Retry only on timeout or temporary errors 126 | var opErr *net.OpError 127 | if errors.As(err, &opErr) && (opErr.Timeout() || opErr.Temporary()) { 128 | // Exponential backoff: doubling the delay for each retry 129 | time.Sleep(delay) 130 | delay = delay * 2 131 | continue 132 | } 133 | 134 | // Break out of the loop on non-retryable errors 135 | break 136 | } 137 | 138 | // Classify the final error 139 | switch { 140 | case errors.Is(lastErr, io.EOF): 141 | return 0, &wire.WireError{Kind: wire.Empty, Cause: lastErr} 142 | case errors.Is(lastErr, io.ErrUnexpectedEOF): 143 | w.Close() 144 | return 0, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 145 | case strings.Contains(lastErr.Error(), "use of closed network connection"): 146 | w.Close() 147 | return 0, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 148 | case func() bool { 149 | var opErr *net.OpError 150 | return errors.As(lastErr, &opErr) && (opErr.Timeout() || opErr.Temporary()) 151 | }(): 152 | // This case was already checked during retries, but it falls back here if it's a fatal error 153 | w.Close() 154 | return 0, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 155 | default: 156 | // Handle other unknown error types by marking the status as closed 157 | w.Close() 158 | return 0, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 159 | } 160 | } 161 | 162 | func (w *TCPWire) readMessage(size uint32) ([]byte, *wire.WireError) { 163 | buffer := make([]byte, size) 164 | delay := 5 * time.Millisecond 165 | const maxRetries = 5 166 | 167 | var lastErr error 168 | for attempt := 0; attempt < maxRetries; attempt++ { 169 | _, err := io.ReadFull(w.reader, buffer) 170 | if err == nil { 171 | return buffer, nil 172 | } 173 | 174 | lastErr = err 175 | 176 | // Retry only on timeout or temporary errors or EOF in case of partial write 177 | var opErr *net.OpError 178 | if (errors.As(err, &opErr) && (opErr.Timeout() || opErr.Temporary())) || errors.Is(err, io.EOF) { 179 | // Exponential backoff: doubling the delay for each retry 180 | time.Sleep(delay) 181 | delay = delay * 2 182 | continue 183 | } 184 | 185 | // Break out of the loop on non-retryable errors 186 | break 187 | } 188 | 189 | // Classify the final error 190 | switch { 191 | case errors.Is(lastErr, io.EOF): 192 | w.status = Closed 193 | return buffer, &wire.WireError{Kind: wire.CorruptMessage, Cause: lastErr} 194 | case errors.Is(lastErr, io.ErrUnexpectedEOF): 195 | w.status = Closed 196 | return buffer, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 197 | case strings.Contains(lastErr.Error(), "use of closed network connection"): 198 | w.status = Closed 199 | return buffer, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 200 | case func() bool { 201 | var opErr *net.OpError 202 | return errors.As(lastErr, &opErr) && (opErr.Timeout() || opErr.Temporary()) 203 | }(): 204 | // This case was already checked during retries, but it falls back here if it's a fatal error 205 | w.status = Closed 206 | return buffer, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 207 | default: 208 | // Handle other unknown error types by marking the status as closed 209 | w.status = Closed 210 | return buffer, &wire.WireError{Kind: wire.Terminated, Cause: lastErr} 211 | } 212 | } 213 | 214 | func (w *TCPWire) write(buffer []byte) *wire.WireError { 215 | var totalWritten int 216 | partialWriteRetries := 0 217 | backoffRetries := 0 218 | 219 | const maxPartialWriteRetries = 10 220 | const maxBackoffRetries = 5 221 | 222 | backoffDelay := 5 * time.Millisecond 223 | var lastRetryableErr error 224 | 225 | for totalWritten < len(buffer) { 226 | n, err := w.conn.Write(buffer[totalWritten:]) 227 | isPartial := n == 0 || n < len(buffer[totalWritten:]) || errors.Is(err, io.ErrShortWrite) 228 | totalWritten += n 229 | 230 | if err != nil && !errors.Is(err, io.ErrShortWrite) { 231 | lastRetryableErr = err 232 | if errors.Is(err, io.ErrClosedPipe) { 233 | w.status = Closed 234 | return &wire.WireError{Kind: wire.Terminated, Cause: err} 235 | } 236 | 237 | var opErr *net.OpError 238 | if errors.As(err, &opErr) && (opErr.Timeout() || opErr.Temporary()) { 239 | if backoffRetries > maxBackoffRetries { 240 | w.status = Closed 241 | return &wire.WireError{ 242 | Kind: wire.Terminated, 243 | Cause: fmt.Errorf("max backoff retries reached: %w", lastRetryableErr), 244 | } 245 | } 246 | 247 | backoffRetries++ 248 | time.Sleep(backoffDelay) 249 | backoffDelay *= 2 250 | continue 251 | } 252 | 253 | w.status = Closed 254 | return &wire.WireError{Kind: wire.Terminated, Cause: err} 255 | } 256 | 257 | if isPartial { 258 | if partialWriteRetries >= maxPartialWriteRetries { 259 | w.status = Closed 260 | return &wire.WireError{ 261 | Kind: wire.Terminated, 262 | Cause: fmt.Errorf("max partial write retries reached: %w", err), 263 | } 264 | } 265 | 266 | partialWriteRetries++ 267 | continue 268 | } 269 | } 270 | 271 | return nil 272 | } 273 | 274 | func prefix(msgSize int, buffer []byte) { 275 | binary.BigEndian.PutUint32(buffer[:prefixSize], uint32(msgSize)) 276 | } 277 | -------------------------------------------------------------------------------- /internal/tcp_wire_test.go: -------------------------------------------------------------------------------- 1 | package internal 2 | 3 | import ( 4 | "bytes" 5 | "io" 6 | "testing" 7 | 8 | "github.com/dicedb/dicedb-go/mock" 9 | "go.uber.org/mock/gomock" 10 | ) 11 | 12 | func TestClosesConnOnClose(t *testing.T) { 13 | // arrange 14 | ctrl := gomock.NewController(t) 15 | mockConn := mock.NewMockConn(ctrl) 16 | mockConn.EXPECT().Close().Times(1) 17 | 18 | // act 19 | wire := NewTCPWire(50, mockConn) 20 | wire.Close() 21 | 22 | // assert 23 | ctrl.Finish() 24 | } 25 | 26 | func TestSend(t *testing.T) { 27 | // arrange 28 | ctrl := gomock.NewController(t) 29 | defer ctrl.Finish() 30 | msg := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 31 | prefix := []byte{0, 0, 0, byte(len(msg))} 32 | want := append(prefix, msg...) 33 | 34 | mockConn := mock.NewMockConn(ctrl) 35 | var captured []byte 36 | mockConn.EXPECT().Write(gomock.Any()).MinTimes(1).DoAndReturn(func(buffer []byte) (int, error) { 37 | captured = append(captured, buffer...) 38 | 39 | return len(buffer), nil 40 | }) 41 | 42 | wire := NewTCPWire(50, mockConn) 43 | 44 | // act 45 | err := wire.Send(msg) 46 | 47 | // assert 48 | if err != nil { 49 | t.Errorf("Send() error = %v", err) 50 | } 51 | 52 | if !bytes.Equal(captured, want) { 53 | t.Errorf("Send() captured = %v, want %v", captured, want) 54 | } 55 | } 56 | 57 | func TestReceive(t *testing.T) { 58 | // arrange 59 | ctrl := gomock.NewController(t) 60 | defer ctrl.Finish() 61 | 62 | want := []byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9} 63 | prefix := []byte{0, 0, 0, byte(len(want))} 64 | msg := append(prefix, want...) 65 | mockConn := mock.NewMockConn(ctrl) 66 | 67 | pos := 0 68 | mockConn.EXPECT().Read(gomock.Any()).AnyTimes().DoAndReturn(func(buffer []byte) (int, error) { 69 | remaining := len(msg) - pos 70 | if remaining == 0 { 71 | return 0, io.EOF // End of message 72 | } 73 | 74 | capacity := len(buffer) 75 | if capacity > remaining { 76 | capacity = remaining 77 | } 78 | 79 | // Copy the appropriate amount of data from msg to the buffer 80 | copy(buffer, msg[pos:pos+capacity]) 81 | pos += capacity 82 | 83 | // Return the number of bytes read and no error 84 | return capacity, nil 85 | }) 86 | wire := NewTCPWire(50, mockConn) 87 | 88 | // act 89 | buffer, err := wire.Receive() 90 | 91 | // assert 92 | if err != nil { 93 | t.Errorf("Receive() error = %v", err) 94 | } 95 | 96 | if !bytes.Equal(buffer, want) { 97 | t.Errorf("Receive() captured = %v, want %v", buffer, want) 98 | } 99 | } 100 | -------------------------------------------------------------------------------- /internal/wire.go: -------------------------------------------------------------------------------- 1 | package internal 2 | 3 | import "github.com/dicedb/dicedb-go/wire" 4 | 5 | type Wire interface { 6 | Send([]byte) *wire.WireError 7 | Receive() ([]byte, *wire.WireError) 8 | Close() 9 | } 10 | -------------------------------------------------------------------------------- /main.go: -------------------------------------------------------------------------------- 1 | package dicedb 2 | 3 | import ( 4 | "fmt" 5 | "log/slog" 6 | "strings" 7 | "sync" 8 | "time" 9 | 10 | "github.com/dicedb/dicedb-go/wire" 11 | "github.com/google/uuid" 12 | ) 13 | 14 | const maxResponseSize = 32 * 1024 * 1024 // 32 MB 15 | 16 | type Client struct { 17 | id string 18 | mainMu sync.Mutex 19 | mainRetrier *Retrier 20 | mainWire *ClientWire 21 | watchRetrier *Retrier 22 | watchWire *ClientWire 23 | watchCh chan *wire.Result 24 | host string 25 | port int 26 | } 27 | 28 | type option func(*Client) 29 | 30 | func WithID(id string) option { 31 | return func(c *Client) { 32 | c.id = id 33 | } 34 | } 35 | 36 | func NewClient(host string, port int, opts ...option) (*Client, error) { 37 | mainRetrier := NewRetrier(3, 5*time.Second) 38 | clientWire, err := ExecuteWithResult(mainRetrier, []wire.ErrKind{wire.NotEstablished}, func() (*ClientWire, *wire.WireError) { 39 | return NewClientWire(maxResponseSize, host, port) 40 | }, noop) 41 | 42 | if err != nil { 43 | if err.Kind == wire.NotEstablished { 44 | return nil, fmt.Errorf("could not connect to dicedb server after %d retries: %w", mainRetrier.maxRetries, err) 45 | } 46 | 47 | return nil, fmt.Errorf("unexpected error when establishing server connection, report this to dicedb maintainers: %w", err) 48 | } 49 | 50 | client := &Client{ 51 | mainRetrier: mainRetrier, 52 | mainWire: clientWire, 53 | host: host, 54 | port: port, 55 | } 56 | 57 | for _, opt := range opts { 58 | opt(client) 59 | } 60 | 61 | if client.id == "" { 62 | client.id = uuid.New().String() 63 | } 64 | 65 | if resp := client.Fire(&wire.Command{ 66 | Cmd: "HANDSHAKE", 67 | Args: []string{client.id, "command"}, 68 | }); resp.Status == wire.Status_ERR { 69 | return nil, fmt.Errorf("could not complete the handshake: %s", resp.Message) 70 | } 71 | 72 | return client, nil 73 | } 74 | 75 | func (c *Client) fire(cmd *wire.Command, clientWire *ClientWire) *wire.Result { 76 | c.mainMu.Lock() 77 | defer c.mainMu.Unlock() 78 | 79 | err := ExecuteVoid(c.mainRetrier, []wire.ErrKind{wire.Terminated}, func() *wire.WireError { 80 | return clientWire.Send(cmd) 81 | }, c.restoreMainWire) 82 | 83 | if err != nil { 84 | var message string 85 | 86 | switch err.Kind { 87 | case wire.Terminated: 88 | message = fmt.Sprintf("failied to send command, connection terminated: %s", err.Cause) 89 | case wire.CorruptMessage: 90 | message = fmt.Sprintf("failied to send command, corrupt message: %s", err.Cause) 91 | default: 92 | message = fmt.Sprintf("failed to send command: unrecognized error, this should be reported to DiceDB maintainers: %s", err.Cause) 93 | } 94 | 95 | return &wire.Result{ 96 | Status: wire.Status_ERR, 97 | Message: message, 98 | } 99 | } 100 | 101 | resp, err := clientWire.Receive() 102 | if err != nil { 103 | return &wire.Result{ 104 | Status: wire.Status_ERR, 105 | Message: fmt.Sprintf("failed to receive response: %s", err.Cause), 106 | } 107 | } 108 | 109 | return resp 110 | } 111 | 112 | func (c *Client) Fire(cmd *wire.Command) *wire.Result { 113 | return c.fire(cmd, c.mainWire) 114 | } 115 | 116 | func (c *Client) FireString(cmdStr string) *wire.Result { 117 | cmdStr = strings.TrimSpace(cmdStr) 118 | tokens := strings.Split(cmdStr, " ") 119 | 120 | var args []string 121 | var cmd = tokens[0] 122 | if len(tokens) > 1 { 123 | args = tokens[1:] 124 | } 125 | 126 | return c.Fire(&wire.Command{ 127 | Cmd: cmd, 128 | Args: args, 129 | }) 130 | } 131 | 132 | func (c *Client) WatchCh() (<-chan *wire.Result, error) { 133 | var err *wire.WireError 134 | if c.watchCh != nil { 135 | return c.watchCh, nil 136 | } 137 | 138 | c.watchCh = make(chan *wire.Result) 139 | c.watchRetrier = NewRetrier(5, 5*time.Second) 140 | c.watchWire, err = NewClientWire(maxResponseSize, c.host, c.port) 141 | if err != nil { 142 | return nil, fmt.Errorf("Failed to establish watch connection with server: %w", err) 143 | } 144 | 145 | if resp := c.fire(&wire.Command{ 146 | Cmd: "HANDSHAKE", 147 | Args: []string{c.id, "watch"}, 148 | }, c.watchWire); resp.Status == wire.Status_ERR { 149 | return nil, fmt.Errorf("could not complete the handshake: %s", resp.Message) 150 | } 151 | 152 | go c.watch() 153 | 154 | return c.watchCh, nil 155 | } 156 | 157 | func (c *Client) watch() { 158 | for { 159 | resp, err := ExecuteWithResult(c.watchRetrier, []wire.ErrKind{wire.Terminated}, c.watchWire.Receive, c.restoreWatchWire) 160 | 161 | if err != nil { 162 | slog.Error("watch connection has been terminated due to an error", "err", err) 163 | close(c.watchCh) 164 | c.watchWire.Close() 165 | break 166 | } 167 | 168 | c.watchCh <- resp 169 | } 170 | } 171 | 172 | func (c *Client) Close() { 173 | c.mainWire.Close() 174 | if c.watchCh != nil { 175 | c.watchWire.Close() 176 | close(c.watchCh) 177 | } 178 | } 179 | 180 | func (c *Client) restoreMainWire() *wire.WireError { 181 | return c.restoreWire(c.mainWire) 182 | } 183 | 184 | func (c *Client) restoreWatchWire() *wire.WireError { 185 | return c.restoreWire(c.watchWire) 186 | } 187 | 188 | func (c *Client) restoreWire(dst *ClientWire) *wire.WireError { // nolint:staticcheck 189 | slog.Warn("trying to restore connection with server...") 190 | var err *wire.WireError 191 | 192 | dst, err = NewClientWire(maxResponseSize, c.host, c.port) // nolint:ineffassign,staticcheck 193 | if err != nil { 194 | slog.Warn("failed to restore connection with server", "error", err) 195 | return err 196 | } 197 | 198 | slog.Info("connection restored successfully") 199 | return nil 200 | } 201 | 202 | func noop() *wire.WireError { 203 | return nil 204 | } 205 | -------------------------------------------------------------------------------- /main_test.go: -------------------------------------------------------------------------------- 1 | package dicedb 2 | 3 | import ( 4 | "errors" 5 | "testing" 6 | 7 | "github.com/dicedb/dicedb-go/wire" 8 | ) 9 | 10 | func TestNewClient(t *testing.T) { 11 | tests := []struct { 12 | name string 13 | host string 14 | port int 15 | wantNil bool 16 | err error 17 | }{ 18 | { 19 | name: "valid connection", 20 | host: "localhost", 21 | port: 7379, 22 | wantNil: false, 23 | err: nil, 24 | }, 25 | { 26 | name: "invalid port", 27 | host: "localhost", 28 | port: -1, 29 | wantNil: true, 30 | err: errors.New("could not connect to dicedb server after 3 retries: dial tcp: address -1: invalid port"), 31 | }, 32 | { 33 | name: "unable to connect", 34 | host: "localhost", 35 | port: 9999, 36 | wantNil: true, 37 | err: errors.New("could not connect to dicedb server after 3 retries: dial tcp 127.0.0.1:9999: connect: connection refused"), 38 | }, 39 | } 40 | 41 | for _, tt := range tests { 42 | t.Run(tt.name, func(t *testing.T) { 43 | client, err := NewClient(tt.host, tt.port) 44 | if (client == nil) != tt.wantNil { 45 | t.Errorf("NewClient() got = %v, %s, want nil = %v, err = %v", client, err, tt.wantNil, tt.err) 46 | } 47 | if err != nil && err.Error() != tt.err.Error() { 48 | t.Errorf("NewClient() got = %v, %s, want nil = %v, err = %v", client, err, tt.wantNil, tt.err) 49 | } 50 | }) 51 | } 52 | } 53 | 54 | func TestClient_Fire(t *testing.T) { 55 | client, err := NewClient("localhost", 7379) 56 | if err != nil { 57 | t.Fatalf("failed to create client: %v", err) 58 | } 59 | 60 | tests := []struct { 61 | name string 62 | mockConn *Client 63 | cmd *wire.Command 64 | result *wire.Result 65 | err error 66 | }{ 67 | { 68 | name: "successful command", 69 | mockConn: client, 70 | cmd: &wire.Command{Cmd: "PING"}, 71 | result: &wire.Result{Status: wire.Status_OK, Response: &wire.Result_PINGRes{PINGRes: &wire.PINGRes{Message: "PONG"}}}, 72 | err: nil, 73 | }, 74 | } 75 | 76 | for _, tt := range tests { 77 | t.Run(tt.name, func(t *testing.T) { 78 | resp := tt.mockConn.Fire(tt.cmd) 79 | if tt.err != nil && resp.Status != wire.Status_ERR { 80 | t.Errorf("Fire() expected error: %v, want: %v", resp.Status, tt.err) 81 | } 82 | if resp.GetPINGRes().Message != tt.result.GetPINGRes().Message { 83 | t.Errorf("Fire() unexpected response: %v, want: %v", resp.GetPINGRes().Message, tt.result.GetPINGRes().Message) 84 | } 85 | }) 86 | } 87 | } 88 | -------------------------------------------------------------------------------- /mock/conn.go: -------------------------------------------------------------------------------- 1 | // Code generated by MockGen. DO NOT EDIT. 2 | // Source: net (interfaces: Conn) 3 | // 4 | // Generated by this command: 5 | // 6 | // mockgen -package=mock net Conn 7 | // 8 | 9 | // Package mock is a generated GoMock package. 10 | package mock 11 | 12 | import ( 13 | net "net" 14 | reflect "reflect" 15 | time "time" 16 | 17 | gomock "go.uber.org/mock/gomock" 18 | ) 19 | 20 | // MockConn is a mock of Conn interface. 21 | type MockConn struct { 22 | ctrl *gomock.Controller 23 | recorder *MockConnMockRecorder 24 | isgomock struct{} 25 | } 26 | 27 | // MockConnMockRecorder is the mock recorder for MockConn. 28 | type MockConnMockRecorder struct { 29 | mock *MockConn 30 | } 31 | 32 | // NewMockConn creates a new mock instance. 33 | func NewMockConn(ctrl *gomock.Controller) *MockConn { 34 | mock := &MockConn{ctrl: ctrl} 35 | mock.recorder = &MockConnMockRecorder{mock} 36 | return mock 37 | } 38 | 39 | // EXPECT returns an object that allows the caller to indicate expected use. 40 | func (m *MockConn) EXPECT() *MockConnMockRecorder { 41 | return m.recorder 42 | } 43 | 44 | // Close mocks base method. 45 | func (m *MockConn) Close() error { 46 | m.ctrl.T.Helper() 47 | ret := m.ctrl.Call(m, "Close") 48 | ret0, _ := ret[0].(error) 49 | return ret0 50 | } 51 | 52 | // Close indicates an expected call of Close. 53 | func (mr *MockConnMockRecorder) Close() *gomock.Call { 54 | mr.mock.ctrl.T.Helper() 55 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockConn)(nil).Close)) 56 | } 57 | 58 | // LocalAddr mocks base method. 59 | func (m *MockConn) LocalAddr() net.Addr { 60 | m.ctrl.T.Helper() 61 | ret := m.ctrl.Call(m, "LocalAddr") 62 | ret0, _ := ret[0].(net.Addr) 63 | return ret0 64 | } 65 | 66 | // LocalAddr indicates an expected call of LocalAddr. 67 | func (mr *MockConnMockRecorder) LocalAddr() *gomock.Call { 68 | mr.mock.ctrl.T.Helper() 69 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "LocalAddr", reflect.TypeOf((*MockConn)(nil).LocalAddr)) 70 | } 71 | 72 | // Read mocks base method. 73 | func (m *MockConn) Read(b []byte) (int, error) { 74 | m.ctrl.T.Helper() 75 | ret := m.ctrl.Call(m, "Read", b) 76 | ret0, _ := ret[0].(int) 77 | ret1, _ := ret[1].(error) 78 | return ret0, ret1 79 | } 80 | 81 | // Read indicates an expected call of Read. 82 | func (mr *MockConnMockRecorder) Read(b any) *gomock.Call { 83 | mr.mock.ctrl.T.Helper() 84 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockConn)(nil).Read), b) 85 | } 86 | 87 | // RemoteAddr mocks base method. 88 | func (m *MockConn) RemoteAddr() net.Addr { 89 | m.ctrl.T.Helper() 90 | ret := m.ctrl.Call(m, "RemoteAddr") 91 | ret0, _ := ret[0].(net.Addr) 92 | return ret0 93 | } 94 | 95 | // RemoteAddr indicates an expected call of RemoteAddr. 96 | func (mr *MockConnMockRecorder) RemoteAddr() *gomock.Call { 97 | mr.mock.ctrl.T.Helper() 98 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoteAddr", reflect.TypeOf((*MockConn)(nil).RemoteAddr)) 99 | } 100 | 101 | // SetDeadline mocks base method. 102 | func (m *MockConn) SetDeadline(t time.Time) error { 103 | m.ctrl.T.Helper() 104 | ret := m.ctrl.Call(m, "SetDeadline", t) 105 | ret0, _ := ret[0].(error) 106 | return ret0 107 | } 108 | 109 | // SetDeadline indicates an expected call of SetDeadline. 110 | func (mr *MockConnMockRecorder) SetDeadline(t any) *gomock.Call { 111 | mr.mock.ctrl.T.Helper() 112 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetDeadline", reflect.TypeOf((*MockConn)(nil).SetDeadline), t) 113 | } 114 | 115 | // SetReadDeadline mocks base method. 116 | func (m *MockConn) SetReadDeadline(t time.Time) error { 117 | m.ctrl.T.Helper() 118 | ret := m.ctrl.Call(m, "SetReadDeadline", t) 119 | ret0, _ := ret[0].(error) 120 | return ret0 121 | } 122 | 123 | // SetReadDeadline indicates an expected call of SetReadDeadline. 124 | func (mr *MockConnMockRecorder) SetReadDeadline(t any) *gomock.Call { 125 | mr.mock.ctrl.T.Helper() 126 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetReadDeadline", reflect.TypeOf((*MockConn)(nil).SetReadDeadline), t) 127 | } 128 | 129 | // SetWriteDeadline mocks base method. 130 | func (m *MockConn) SetWriteDeadline(t time.Time) error { 131 | m.ctrl.T.Helper() 132 | ret := m.ctrl.Call(m, "SetWriteDeadline", t) 133 | ret0, _ := ret[0].(error) 134 | return ret0 135 | } 136 | 137 | // SetWriteDeadline indicates an expected call of SetWriteDeadline. 138 | func (mr *MockConnMockRecorder) SetWriteDeadline(t any) *gomock.Call { 139 | mr.mock.ctrl.T.Helper() 140 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetWriteDeadline", reflect.TypeOf((*MockConn)(nil).SetWriteDeadline), t) 141 | } 142 | 143 | // Write mocks base method. 144 | func (m *MockConn) Write(b []byte) (int, error) { 145 | m.ctrl.T.Helper() 146 | ret := m.ctrl.Call(m, "Write", b) 147 | ret0, _ := ret[0].(int) 148 | ret1, _ := ret[1].(error) 149 | return ret0, ret1 150 | } 151 | 152 | // Write indicates an expected call of Write. 153 | func (mr *MockConnMockRecorder) Write(b any) *gomock.Call { 154 | mr.mock.ctrl.T.Helper() 155 | return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockConn)(nil).Write), b) 156 | } 157 | -------------------------------------------------------------------------------- /retrier.go: -------------------------------------------------------------------------------- 1 | package dicedb 2 | 3 | import ( 4 | "github.com/dicedb/dicedb-go/wire" 5 | "sync" 6 | "time" 7 | ) 8 | 9 | type Retrier struct { 10 | maxRetries int 11 | retryWindow time.Duration 12 | retryCount int 13 | lastAttempt time.Time 14 | mu sync.Mutex 15 | } 16 | 17 | func ExecuteWithResult[T any](r *Retrier, retryOn []wire.ErrKind, op func() (*T, *wire.WireError), beforeRetry func() *wire.WireError) (*T, *wire.WireError) { 18 | return executeWithRetry(r, retryOn, beforeRetry, op) 19 | } 20 | 21 | func ExecuteVoid(r *Retrier, retryOn []wire.ErrKind, op func() *wire.WireError, beforeRetry func() *wire.WireError) *wire.WireError { 22 | _, err := executeWithRetry(r, retryOn, beforeRetry, func() (*struct{}, *wire.WireError) { 23 | return nil, op() 24 | }) 25 | 26 | return err 27 | } 28 | 29 | func NewRetrier(maxRetries int, retryWindow time.Duration) *Retrier { 30 | return &Retrier{ 31 | maxRetries: maxRetries, 32 | retryWindow: retryWindow, 33 | lastAttempt: time.Now(), 34 | } 35 | } 36 | 37 | func (r *Retrier) Allow() bool { 38 | r.mu.Lock() 39 | defer r.mu.Unlock() 40 | 41 | r.resetIfWindowPassed() 42 | return r.retryCount < r.maxRetries 43 | } 44 | 45 | func (r *Retrier) Failure() { 46 | r.mu.Lock() 47 | defer r.mu.Unlock() 48 | 49 | r.resetIfWindowPassed() 50 | r.retryCount++ 51 | r.lastAttempt = time.Now() 52 | } 53 | 54 | func (r *Retrier) Success() { 55 | r.mu.Lock() 56 | defer r.mu.Unlock() 57 | 58 | r.retryCount = 0 59 | r.lastAttempt = time.Now() 60 | } 61 | 62 | func (r *Retrier) resetIfWindowPassed() { 63 | if time.Since(r.lastAttempt) > r.retryWindow { 64 | r.retryCount = 0 65 | } 66 | } 67 | 68 | func shouldRetry(kind wire.ErrKind, retryOn []wire.ErrKind) bool { 69 | for _, k := range retryOn { 70 | if k == kind { 71 | return true 72 | } 73 | } 74 | return false 75 | } 76 | 77 | func executeWithRetry[T any](r *Retrier, retryOn []wire.ErrKind, beforeRetry func() *wire.WireError, op func() (*T, *wire.WireError)) (*T, *wire.WireError) { 78 | for { 79 | value, err := op() 80 | if err == nil { 81 | r.Success() 82 | return value, nil 83 | } 84 | 85 | r.Failure() 86 | 87 | if shouldRetry(err.Kind, retryOn) && r.Allow() { 88 | if bErr := beforeRetry(); bErr != nil { 89 | return nil, bErr 90 | } 91 | continue 92 | } 93 | 94 | return nil, err 95 | } 96 | } 97 | -------------------------------------------------------------------------------- /server_wire.go: -------------------------------------------------------------------------------- 1 | // Copyright (c) 2022-present, DiceDB contributors 2 | // All rights reserved. Licensed under the BSD 3-Clause License. See LICENSE file in the project root for full license information. 3 | 4 | package dicedb 5 | 6 | import ( 7 | "context" 8 | "fmt" 9 | "net" 10 | "os" 11 | "time" 12 | 13 | "github.com/dicedb/dicedb-go/internal" 14 | "github.com/dicedb/dicedb-go/wire" 15 | ) 16 | 17 | type ServerWire struct { 18 | *internal.ProtobufTCPWire 19 | } 20 | 21 | func NewServerWire(maxMsgSize int, keepAlive int32, clientFD int) (*ServerWire, *wire.WireError) { 22 | file := os.NewFile(uintptr(clientFD), fmt.Sprintf("client-connection-%d", clientFD)) 23 | if file == nil { 24 | return nil, &wire.WireError{ 25 | Kind: wire.NotEstablished, 26 | Cause: fmt.Errorf("failed to create file from file descriptor"), 27 | } 28 | } 29 | 30 | conn, err := net.FileConn(file) 31 | if err != nil { 32 | return nil, &wire.WireError{ 33 | Kind: wire.NotEstablished, 34 | Cause: err, 35 | } 36 | } 37 | 38 | if tcpConn, ok := conn.(*net.TCPConn); ok { 39 | if err := tcpConn.SetNoDelay(true); err != nil { 40 | return nil, &wire.WireError{ 41 | Kind: wire.NotEstablished, 42 | Cause: fmt.Errorf("failed to set TCP_NODELAY: %w", err), 43 | } 44 | } 45 | if err := tcpConn.SetKeepAlive(true); err != nil { 46 | return nil, &wire.WireError{ 47 | Kind: wire.NotEstablished, 48 | Cause: fmt.Errorf("failed to set keepalive: %w", err), 49 | } 50 | } 51 | if err := tcpConn.SetKeepAlivePeriod(time.Duration(keepAlive) * time.Second); err != nil { 52 | return nil, &wire.WireError{ 53 | Kind: wire.NotEstablished, 54 | Cause: fmt.Errorf("failed to set keepalive period: %w", err), 55 | } 56 | } 57 | } 58 | 59 | w := &ServerWire{ 60 | ProtobufTCPWire: internal.NewProtobufTCPWire(maxMsgSize, conn), 61 | } 62 | 63 | return w, nil 64 | } 65 | 66 | func (sw *ServerWire) Send(ctx context.Context, resp *wire.Result) *wire.WireError { 67 | return sw.ProtobufTCPWire.Send(resp) 68 | } 69 | 70 | func (sw *ServerWire) Receive() (*wire.Command, *wire.WireError) { 71 | cmd := &wire.Command{} 72 | 73 | if err := sw.ProtobufTCPWire.Receive(cmd); err != nil { 74 | return nil, err 75 | } 76 | 77 | return cmd, nil 78 | } 79 | 80 | func (sw *ServerWire) Close() { 81 | sw.ProtobufTCPWire.Close() 82 | } 83 | -------------------------------------------------------------------------------- /wal/wal.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. DO NOT EDIT. 2 | // versions: 3 | // protoc-gen-go v1.36.5 4 | // protoc v3.21.12 5 | // source: protos/wal/wal.proto 6 | 7 | package wal 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 | reflect "reflect" 13 | sync "sync" 14 | unsafe "unsafe" 15 | ) 16 | 17 | const ( 18 | // Verify that this generated code is sufficiently up-to-date. 19 | _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 20 | // Verify that runtime/protoimpl is sufficiently up-to-date. 21 | _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 22 | ) 23 | 24 | type ElementType int32 25 | 26 | const ( 27 | ElementType_ELEMENT_TYPE_NOOP ElementType = 0 28 | ElementType_ELEMENT_TYPE_COMMAND ElementType = 1 29 | ) 30 | 31 | // Enum value maps for ElementType. 32 | var ( 33 | ElementType_name = map[int32]string{ 34 | 0: "ELEMENT_TYPE_NOOP", 35 | 1: "ELEMENT_TYPE_COMMAND", 36 | } 37 | ElementType_value = map[string]int32{ 38 | "ELEMENT_TYPE_NOOP": 0, 39 | "ELEMENT_TYPE_COMMAND": 1, 40 | } 41 | ) 42 | 43 | func (x ElementType) Enum() *ElementType { 44 | p := new(ElementType) 45 | *p = x 46 | return p 47 | } 48 | 49 | func (x ElementType) String() string { 50 | return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) 51 | } 52 | 53 | func (ElementType) Descriptor() protoreflect.EnumDescriptor { 54 | return file_protos_wal_wal_proto_enumTypes[0].Descriptor() 55 | } 56 | 57 | func (ElementType) Type() protoreflect.EnumType { 58 | return &file_protos_wal_wal_proto_enumTypes[0] 59 | } 60 | 61 | func (x ElementType) Number() protoreflect.EnumNumber { 62 | return protoreflect.EnumNumber(x) 63 | } 64 | 65 | // Deprecated: Use ElementType.Descriptor instead. 66 | func (ElementType) EnumDescriptor() ([]byte, []int) { 67 | return file_protos_wal_wal_proto_rawDescGZIP(), []int{0} 68 | } 69 | 70 | type Element struct { 71 | state protoimpl.MessageState `protogen:"open.v1"` 72 | Lsn uint64 `protobuf:"varint,1,opt,name=lsn,proto3" json:"lsn,omitempty"` 73 | Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` 74 | ElementType ElementType `protobuf:"varint,3,opt,name=element_type,json=elementType,proto3,enum=wal.ElementType" json:"element_type,omitempty"` 75 | Payload []byte `protobuf:"bytes,4,opt,name=payload,proto3" json:"payload,omitempty"` 76 | unknownFields protoimpl.UnknownFields 77 | sizeCache protoimpl.SizeCache 78 | } 79 | 80 | func (x *Element) Reset() { 81 | *x = Element{} 82 | mi := &file_protos_wal_wal_proto_msgTypes[0] 83 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 84 | ms.StoreMessageInfo(mi) 85 | } 86 | 87 | func (x *Element) String() string { 88 | return protoimpl.X.MessageStringOf(x) 89 | } 90 | 91 | func (*Element) ProtoMessage() {} 92 | 93 | func (x *Element) ProtoReflect() protoreflect.Message { 94 | mi := &file_protos_wal_wal_proto_msgTypes[0] 95 | if x != nil { 96 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 97 | if ms.LoadMessageInfo() == nil { 98 | ms.StoreMessageInfo(mi) 99 | } 100 | return ms 101 | } 102 | return mi.MessageOf(x) 103 | } 104 | 105 | // Deprecated: Use Element.ProtoReflect.Descriptor instead. 106 | func (*Element) Descriptor() ([]byte, []int) { 107 | return file_protos_wal_wal_proto_rawDescGZIP(), []int{0} 108 | } 109 | 110 | func (x *Element) GetLsn() uint64 { 111 | if x != nil { 112 | return x.Lsn 113 | } 114 | return 0 115 | } 116 | 117 | func (x *Element) GetTimestamp() int64 { 118 | if x != nil { 119 | return x.Timestamp 120 | } 121 | return 0 122 | } 123 | 124 | func (x *Element) GetElementType() ElementType { 125 | if x != nil { 126 | return x.ElementType 127 | } 128 | return ElementType_ELEMENT_TYPE_NOOP 129 | } 130 | 131 | func (x *Element) GetPayload() []byte { 132 | if x != nil { 133 | return x.Payload 134 | } 135 | return nil 136 | } 137 | 138 | var File_protos_wal_wal_proto protoreflect.FileDescriptor 139 | 140 | var file_protos_wal_wal_proto_rawDesc = string([]byte{ 141 | 0x0a, 0x14, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x77, 0x61, 0x6c, 0x2f, 0x77, 0x61, 0x6c, 142 | 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x03, 0x77, 0x61, 0x6c, 0x22, 0x88, 0x01, 0x0a, 0x07, 143 | 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6c, 0x73, 0x6e, 0x18, 0x01, 144 | 0x20, 0x01, 0x28, 0x04, 0x52, 0x03, 0x6c, 0x73, 0x6e, 0x12, 0x1c, 0x0a, 0x09, 0x74, 0x69, 0x6d, 145 | 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x02, 0x20, 0x01, 0x28, 0x03, 0x52, 0x09, 0x74, 0x69, 146 | 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x12, 0x33, 0x0a, 0x0c, 0x65, 0x6c, 0x65, 0x6d, 0x65, 147 | 0x6e, 0x74, 0x5f, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0e, 0x32, 0x10, 0x2e, 148 | 0x77, 0x61, 0x6c, 0x2e, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x52, 149 | 0x0b, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x18, 0x0a, 0x07, 150 | 0x70, 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x70, 151 | 0x61, 0x79, 0x6c, 0x6f, 0x61, 0x64, 0x2a, 0x3e, 0x0a, 0x0b, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 152 | 0x74, 0x54, 0x79, 0x70, 0x65, 0x12, 0x15, 0x0a, 0x11, 0x45, 0x4c, 0x45, 0x4d, 0x45, 0x4e, 0x54, 153 | 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x4e, 0x4f, 0x4f, 0x50, 0x10, 0x00, 0x12, 0x18, 0x0a, 0x14, 154 | 0x45, 0x4c, 0x45, 0x4d, 0x45, 0x4e, 0x54, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x5f, 0x43, 0x4f, 0x4d, 155 | 0x4d, 0x41, 0x4e, 0x44, 0x10, 0x01, 0x42, 0x07, 0x5a, 0x05, 0x2e, 0x2f, 0x77, 0x61, 0x6c, 0x62, 156 | 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 157 | }) 158 | 159 | var ( 160 | file_protos_wal_wal_proto_rawDescOnce sync.Once 161 | file_protos_wal_wal_proto_rawDescData []byte 162 | ) 163 | 164 | func file_protos_wal_wal_proto_rawDescGZIP() []byte { 165 | file_protos_wal_wal_proto_rawDescOnce.Do(func() { 166 | file_protos_wal_wal_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_protos_wal_wal_proto_rawDesc), len(file_protos_wal_wal_proto_rawDesc))) 167 | }) 168 | return file_protos_wal_wal_proto_rawDescData 169 | } 170 | 171 | var file_protos_wal_wal_proto_enumTypes = make([]protoimpl.EnumInfo, 1) 172 | var file_protos_wal_wal_proto_msgTypes = make([]protoimpl.MessageInfo, 1) 173 | var file_protos_wal_wal_proto_goTypes = []any{ 174 | (ElementType)(0), // 0: wal.ElementType 175 | (*Element)(nil), // 1: wal.Element 176 | } 177 | var file_protos_wal_wal_proto_depIdxs = []int32{ 178 | 0, // 0: wal.Element.element_type:type_name -> wal.ElementType 179 | 1, // [1:1] is the sub-list for method output_type 180 | 1, // [1:1] is the sub-list for method input_type 181 | 1, // [1:1] is the sub-list for extension type_name 182 | 1, // [1:1] is the sub-list for extension extendee 183 | 0, // [0:1] is the sub-list for field type_name 184 | } 185 | 186 | func init() { file_protos_wal_wal_proto_init() } 187 | func file_protos_wal_wal_proto_init() { 188 | if File_protos_wal_wal_proto != nil { 189 | return 190 | } 191 | type x struct{} 192 | out := protoimpl.TypeBuilder{ 193 | File: protoimpl.DescBuilder{ 194 | GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 195 | RawDescriptor: unsafe.Slice(unsafe.StringData(file_protos_wal_wal_proto_rawDesc), len(file_protos_wal_wal_proto_rawDesc)), 196 | NumEnums: 1, 197 | NumMessages: 1, 198 | NumExtensions: 0, 199 | NumServices: 0, 200 | }, 201 | GoTypes: file_protos_wal_wal_proto_goTypes, 202 | DependencyIndexes: file_protos_wal_wal_proto_depIdxs, 203 | EnumInfos: file_protos_wal_wal_proto_enumTypes, 204 | MessageInfos: file_protos_wal_wal_proto_msgTypes, 205 | }.Build() 206 | File_protos_wal_wal_proto = out.File 207 | file_protos_wal_wal_proto_goTypes = nil 208 | file_protos_wal_wal_proto_depIdxs = nil 209 | } 210 | -------------------------------------------------------------------------------- /wire/cmd.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. DO NOT EDIT. 2 | // versions: 3 | // protoc-gen-go v1.36.5 4 | // protoc v3.21.12 5 | // source: protos/cmd.proto 6 | 7 | package wire 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 | reflect "reflect" 13 | sync "sync" 14 | unsafe "unsafe" 15 | ) 16 | 17 | const ( 18 | // Verify that this generated code is sufficiently up-to-date. 19 | _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 20 | // Verify that runtime/protoimpl is sufficiently up-to-date. 21 | _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 22 | ) 23 | 24 | type Command struct { 25 | state protoimpl.MessageState `protogen:"open.v1"` 26 | Cmd string `protobuf:"bytes,1,opt,name=cmd,proto3" json:"cmd,omitempty"` 27 | Args []string `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"` 28 | unknownFields protoimpl.UnknownFields 29 | sizeCache protoimpl.SizeCache 30 | } 31 | 32 | func (x *Command) Reset() { 33 | *x = Command{} 34 | mi := &file_protos_cmd_proto_msgTypes[0] 35 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 36 | ms.StoreMessageInfo(mi) 37 | } 38 | 39 | func (x *Command) String() string { 40 | return protoimpl.X.MessageStringOf(x) 41 | } 42 | 43 | func (*Command) ProtoMessage() {} 44 | 45 | func (x *Command) ProtoReflect() protoreflect.Message { 46 | mi := &file_protos_cmd_proto_msgTypes[0] 47 | if x != nil { 48 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 49 | if ms.LoadMessageInfo() == nil { 50 | ms.StoreMessageInfo(mi) 51 | } 52 | return ms 53 | } 54 | return mi.MessageOf(x) 55 | } 56 | 57 | // Deprecated: Use Command.ProtoReflect.Descriptor instead. 58 | func (*Command) Descriptor() ([]byte, []int) { 59 | return file_protos_cmd_proto_rawDescGZIP(), []int{0} 60 | } 61 | 62 | func (x *Command) GetCmd() string { 63 | if x != nil { 64 | return x.Cmd 65 | } 66 | return "" 67 | } 68 | 69 | func (x *Command) GetArgs() []string { 70 | if x != nil { 71 | return x.Args 72 | } 73 | return nil 74 | } 75 | 76 | var File_protos_cmd_proto protoreflect.FileDescriptor 77 | 78 | var file_protos_cmd_proto_rawDesc = string([]byte{ 79 | 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x63, 0x6d, 0x64, 0x2e, 0x70, 0x72, 0x6f, 80 | 0x74, 0x6f, 0x12, 0x04, 0x77, 0x69, 0x72, 0x65, 0x22, 0x2f, 0x0a, 0x07, 0x43, 0x6f, 0x6d, 0x6d, 81 | 0x61, 0x6e, 0x64, 0x12, 0x10, 0x0a, 0x03, 0x63, 0x6d, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 82 | 0x52, 0x03, 0x63, 0x6d, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x61, 0x72, 0x67, 0x73, 0x18, 0x02, 0x20, 83 | 0x03, 0x28, 0x09, 0x52, 0x04, 0x61, 0x72, 0x67, 0x73, 0x42, 0x08, 0x5a, 0x06, 0x2e, 0x2f, 0x77, 84 | 0x69, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 85 | }) 86 | 87 | var ( 88 | file_protos_cmd_proto_rawDescOnce sync.Once 89 | file_protos_cmd_proto_rawDescData []byte 90 | ) 91 | 92 | func file_protos_cmd_proto_rawDescGZIP() []byte { 93 | file_protos_cmd_proto_rawDescOnce.Do(func() { 94 | file_protos_cmd_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_protos_cmd_proto_rawDesc), len(file_protos_cmd_proto_rawDesc))) 95 | }) 96 | return file_protos_cmd_proto_rawDescData 97 | } 98 | 99 | var file_protos_cmd_proto_msgTypes = make([]protoimpl.MessageInfo, 1) 100 | var file_protos_cmd_proto_goTypes = []any{ 101 | (*Command)(nil), // 0: wire.Command 102 | } 103 | var file_protos_cmd_proto_depIdxs = []int32{ 104 | 0, // [0:0] is the sub-list for method output_type 105 | 0, // [0:0] is the sub-list for method input_type 106 | 0, // [0:0] is the sub-list for extension type_name 107 | 0, // [0:0] is the sub-list for extension extendee 108 | 0, // [0:0] is the sub-list for field type_name 109 | } 110 | 111 | func init() { file_protos_cmd_proto_init() } 112 | func file_protos_cmd_proto_init() { 113 | if File_protos_cmd_proto != nil { 114 | return 115 | } 116 | type x struct{} 117 | out := protoimpl.TypeBuilder{ 118 | File: protoimpl.DescBuilder{ 119 | GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 120 | RawDescriptor: unsafe.Slice(unsafe.StringData(file_protos_cmd_proto_rawDesc), len(file_protos_cmd_proto_rawDesc)), 121 | NumEnums: 0, 122 | NumMessages: 1, 123 | NumExtensions: 0, 124 | NumServices: 0, 125 | }, 126 | GoTypes: file_protos_cmd_proto_goTypes, 127 | DependencyIndexes: file_protos_cmd_proto_depIdxs, 128 | MessageInfos: file_protos_cmd_proto_msgTypes, 129 | }.Build() 130 | File_protos_cmd_proto = out.File 131 | file_protos_cmd_proto_goTypes = nil 132 | file_protos_cmd_proto_depIdxs = nil 133 | } 134 | -------------------------------------------------------------------------------- /wire/error.go: -------------------------------------------------------------------------------- 1 | package wire 2 | 3 | type ErrKind int 4 | 5 | const ( 6 | NotEstablished ErrKind = 1 7 | Empty ErrKind = 2 8 | Terminated ErrKind = 3 9 | CorruptMessage ErrKind = 4 10 | ) 11 | 12 | type WireError struct { 13 | Kind ErrKind 14 | Cause error 15 | } 16 | 17 | func (e *WireError) Error() string { 18 | return e.Cause.Error() 19 | } 20 | 21 | func (e *WireError) Unwrap() error { 22 | return e.Cause 23 | } 24 | -------------------------------------------------------------------------------- /wire/res.pb.go: -------------------------------------------------------------------------------- 1 | // Code generated by protoc-gen-go. DO NOT EDIT. 2 | // versions: 3 | // protoc-gen-go v1.36.5 4 | // protoc v3.21.12 5 | // source: protos/res.proto 6 | 7 | package wire 8 | 9 | import ( 10 | protoreflect "google.golang.org/protobuf/reflect/protoreflect" 11 | protoimpl "google.golang.org/protobuf/runtime/protoimpl" 12 | reflect "reflect" 13 | sync "sync" 14 | unsafe "unsafe" 15 | ) 16 | 17 | const ( 18 | // Verify that this generated code is sufficiently up-to-date. 19 | _ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion) 20 | // Verify that runtime/protoimpl is sufficiently up-to-date. 21 | _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) 22 | ) 23 | 24 | type Status int32 25 | 26 | const ( 27 | Status_OK Status = 0 28 | Status_ERR Status = 1 29 | ) 30 | 31 | // Enum value maps for Status. 32 | var ( 33 | Status_name = map[int32]string{ 34 | 0: "OK", 35 | 1: "ERR", 36 | } 37 | Status_value = map[string]int32{ 38 | "OK": 0, 39 | "ERR": 1, 40 | } 41 | ) 42 | 43 | func (x Status) Enum() *Status { 44 | p := new(Status) 45 | *p = x 46 | return p 47 | } 48 | 49 | func (x Status) String() string { 50 | return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x)) 51 | } 52 | 53 | func (Status) Descriptor() protoreflect.EnumDescriptor { 54 | return file_protos_res_proto_enumTypes[0].Descriptor() 55 | } 56 | 57 | func (Status) Type() protoreflect.EnumType { 58 | return &file_protos_res_proto_enumTypes[0] 59 | } 60 | 61 | func (x Status) Number() protoreflect.EnumNumber { 62 | return protoreflect.EnumNumber(x) 63 | } 64 | 65 | // Deprecated: Use Status.Descriptor instead. 66 | func (Status) EnumDescriptor() ([]byte, []int) { 67 | return file_protos_res_proto_rawDescGZIP(), []int{0} 68 | } 69 | 70 | type Result struct { 71 | state protoimpl.MessageState `protogen:"open.v1"` 72 | Status Status `protobuf:"varint,1,opt,name=status,proto3,enum=wire.Status" json:"status,omitempty"` 73 | Message string `protobuf:"bytes,2,opt,name=message,proto3" json:"message,omitempty"` 74 | Fingerprint64 uint64 `protobuf:"varint,3,opt,name=fingerprint64,proto3" json:"fingerprint64,omitempty"` 75 | // Types that are valid to be assigned to Response: 76 | // 77 | // *Result_TYPERes 78 | // *Result_PINGRes 79 | // *Result_ECHORes 80 | // *Result_HANDSHAKERes 81 | // *Result_EXISTSRes 82 | // *Result_GETRes 83 | // *Result_SETRes 84 | // *Result_DELRes 85 | // *Result_KEYSRes 86 | // *Result_GETDELRes 87 | // *Result_GETEXRes 88 | // *Result_GETSETRes 89 | // *Result_INCRRes 90 | // *Result_DECRRes 91 | // *Result_INCRBYRes 92 | // *Result_DECRBYRes 93 | // *Result_FLUSHDBRes 94 | // *Result_EXPIRERes 95 | // *Result_EXPIREATRes 96 | // *Result_EXPIRETIMERes 97 | // *Result_TTLRes 98 | // *Result_GETWATCHRes 99 | // *Result_UNWATCHRes 100 | // *Result_HGETRes 101 | // *Result_HSETRes 102 | // *Result_HGETALLRes 103 | // *Result_HGETWATCHRes 104 | // *Result_HGETALLWATCHRes 105 | // *Result_ZADDRes 106 | // *Result_ZCOUNTRes 107 | // *Result_ZRANGERes 108 | // *Result_ZPOPMAXRes 109 | // *Result_ZREMRes 110 | // *Result_ZPOPMINRes 111 | // *Result_ZRANKRes 112 | // *Result_ZCARDRes 113 | // *Result_ZRANGEWATCHRes 114 | // *Result_ZCOUNTWATCHRes 115 | // *Result_ZCARDWATCHRes 116 | // *Result_ZRANKWATCHRes 117 | // *Result_GEOADDRes 118 | // *Result_GEODISTRes 119 | // *Result_GEOSEARCHRes 120 | // *Result_GEOHASHRes 121 | // *Result_GEOPOSRes 122 | Response isResult_Response `protobuf_oneof:"response"` 123 | unknownFields protoimpl.UnknownFields 124 | sizeCache protoimpl.SizeCache 125 | } 126 | 127 | func (x *Result) Reset() { 128 | *x = Result{} 129 | mi := &file_protos_res_proto_msgTypes[0] 130 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 131 | ms.StoreMessageInfo(mi) 132 | } 133 | 134 | func (x *Result) String() string { 135 | return protoimpl.X.MessageStringOf(x) 136 | } 137 | 138 | func (*Result) ProtoMessage() {} 139 | 140 | func (x *Result) ProtoReflect() protoreflect.Message { 141 | mi := &file_protos_res_proto_msgTypes[0] 142 | if x != nil { 143 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 144 | if ms.LoadMessageInfo() == nil { 145 | ms.StoreMessageInfo(mi) 146 | } 147 | return ms 148 | } 149 | return mi.MessageOf(x) 150 | } 151 | 152 | // Deprecated: Use Result.ProtoReflect.Descriptor instead. 153 | func (*Result) Descriptor() ([]byte, []int) { 154 | return file_protos_res_proto_rawDescGZIP(), []int{0} 155 | } 156 | 157 | func (x *Result) GetStatus() Status { 158 | if x != nil { 159 | return x.Status 160 | } 161 | return Status_OK 162 | } 163 | 164 | func (x *Result) GetMessage() string { 165 | if x != nil { 166 | return x.Message 167 | } 168 | return "" 169 | } 170 | 171 | func (x *Result) GetFingerprint64() uint64 { 172 | if x != nil { 173 | return x.Fingerprint64 174 | } 175 | return 0 176 | } 177 | 178 | func (x *Result) GetResponse() isResult_Response { 179 | if x != nil { 180 | return x.Response 181 | } 182 | return nil 183 | } 184 | 185 | func (x *Result) GetTYPERes() *TYPERes { 186 | if x != nil { 187 | if x, ok := x.Response.(*Result_TYPERes); ok { 188 | return x.TYPERes 189 | } 190 | } 191 | return nil 192 | } 193 | 194 | func (x *Result) GetPINGRes() *PINGRes { 195 | if x != nil { 196 | if x, ok := x.Response.(*Result_PINGRes); ok { 197 | return x.PINGRes 198 | } 199 | } 200 | return nil 201 | } 202 | 203 | func (x *Result) GetECHORes() *ECHORes { 204 | if x != nil { 205 | if x, ok := x.Response.(*Result_ECHORes); ok { 206 | return x.ECHORes 207 | } 208 | } 209 | return nil 210 | } 211 | 212 | func (x *Result) GetHANDSHAKERes() *HANDSHAKERes { 213 | if x != nil { 214 | if x, ok := x.Response.(*Result_HANDSHAKERes); ok { 215 | return x.HANDSHAKERes 216 | } 217 | } 218 | return nil 219 | } 220 | 221 | func (x *Result) GetEXISTSRes() *EXISTSRes { 222 | if x != nil { 223 | if x, ok := x.Response.(*Result_EXISTSRes); ok { 224 | return x.EXISTSRes 225 | } 226 | } 227 | return nil 228 | } 229 | 230 | func (x *Result) GetGETRes() *GETRes { 231 | if x != nil { 232 | if x, ok := x.Response.(*Result_GETRes); ok { 233 | return x.GETRes 234 | } 235 | } 236 | return nil 237 | } 238 | 239 | func (x *Result) GetSETRes() *SETRes { 240 | if x != nil { 241 | if x, ok := x.Response.(*Result_SETRes); ok { 242 | return x.SETRes 243 | } 244 | } 245 | return nil 246 | } 247 | 248 | func (x *Result) GetDELRes() *DELRes { 249 | if x != nil { 250 | if x, ok := x.Response.(*Result_DELRes); ok { 251 | return x.DELRes 252 | } 253 | } 254 | return nil 255 | } 256 | 257 | func (x *Result) GetKEYSRes() *KEYSRes { 258 | if x != nil { 259 | if x, ok := x.Response.(*Result_KEYSRes); ok { 260 | return x.KEYSRes 261 | } 262 | } 263 | return nil 264 | } 265 | 266 | func (x *Result) GetGETDELRes() *GETDELRes { 267 | if x != nil { 268 | if x, ok := x.Response.(*Result_GETDELRes); ok { 269 | return x.GETDELRes 270 | } 271 | } 272 | return nil 273 | } 274 | 275 | func (x *Result) GetGETEXRes() *GETEXRes { 276 | if x != nil { 277 | if x, ok := x.Response.(*Result_GETEXRes); ok { 278 | return x.GETEXRes 279 | } 280 | } 281 | return nil 282 | } 283 | 284 | func (x *Result) GetGETSETRes() *GETSETRes { 285 | if x != nil { 286 | if x, ok := x.Response.(*Result_GETSETRes); ok { 287 | return x.GETSETRes 288 | } 289 | } 290 | return nil 291 | } 292 | 293 | func (x *Result) GetINCRRes() *INCRRes { 294 | if x != nil { 295 | if x, ok := x.Response.(*Result_INCRRes); ok { 296 | return x.INCRRes 297 | } 298 | } 299 | return nil 300 | } 301 | 302 | func (x *Result) GetDECRRes() *DECRRes { 303 | if x != nil { 304 | if x, ok := x.Response.(*Result_DECRRes); ok { 305 | return x.DECRRes 306 | } 307 | } 308 | return nil 309 | } 310 | 311 | func (x *Result) GetINCRBYRes() *INCRBYRes { 312 | if x != nil { 313 | if x, ok := x.Response.(*Result_INCRBYRes); ok { 314 | return x.INCRBYRes 315 | } 316 | } 317 | return nil 318 | } 319 | 320 | func (x *Result) GetDECRBYRes() *DECRBYRes { 321 | if x != nil { 322 | if x, ok := x.Response.(*Result_DECRBYRes); ok { 323 | return x.DECRBYRes 324 | } 325 | } 326 | return nil 327 | } 328 | 329 | func (x *Result) GetFLUSHDBRes() *FLUSHDBRes { 330 | if x != nil { 331 | if x, ok := x.Response.(*Result_FLUSHDBRes); ok { 332 | return x.FLUSHDBRes 333 | } 334 | } 335 | return nil 336 | } 337 | 338 | func (x *Result) GetEXPIRERes() *EXPIRERes { 339 | if x != nil { 340 | if x, ok := x.Response.(*Result_EXPIRERes); ok { 341 | return x.EXPIRERes 342 | } 343 | } 344 | return nil 345 | } 346 | 347 | func (x *Result) GetEXPIREATRes() *EXPIREATRes { 348 | if x != nil { 349 | if x, ok := x.Response.(*Result_EXPIREATRes); ok { 350 | return x.EXPIREATRes 351 | } 352 | } 353 | return nil 354 | } 355 | 356 | func (x *Result) GetEXPIRETIMERes() *EXPIRETIMERes { 357 | if x != nil { 358 | if x, ok := x.Response.(*Result_EXPIRETIMERes); ok { 359 | return x.EXPIRETIMERes 360 | } 361 | } 362 | return nil 363 | } 364 | 365 | func (x *Result) GetTTLRes() *TTLRes { 366 | if x != nil { 367 | if x, ok := x.Response.(*Result_TTLRes); ok { 368 | return x.TTLRes 369 | } 370 | } 371 | return nil 372 | } 373 | 374 | func (x *Result) GetGETWATCHRes() *GETWATCHRes { 375 | if x != nil { 376 | if x, ok := x.Response.(*Result_GETWATCHRes); ok { 377 | return x.GETWATCHRes 378 | } 379 | } 380 | return nil 381 | } 382 | 383 | func (x *Result) GetUNWATCHRes() *UNWATCHRes { 384 | if x != nil { 385 | if x, ok := x.Response.(*Result_UNWATCHRes); ok { 386 | return x.UNWATCHRes 387 | } 388 | } 389 | return nil 390 | } 391 | 392 | func (x *Result) GetHGETRes() *HGETRes { 393 | if x != nil { 394 | if x, ok := x.Response.(*Result_HGETRes); ok { 395 | return x.HGETRes 396 | } 397 | } 398 | return nil 399 | } 400 | 401 | func (x *Result) GetHSETRes() *HSETRes { 402 | if x != nil { 403 | if x, ok := x.Response.(*Result_HSETRes); ok { 404 | return x.HSETRes 405 | } 406 | } 407 | return nil 408 | } 409 | 410 | func (x *Result) GetHGETALLRes() *HGETALLRes { 411 | if x != nil { 412 | if x, ok := x.Response.(*Result_HGETALLRes); ok { 413 | return x.HGETALLRes 414 | } 415 | } 416 | return nil 417 | } 418 | 419 | func (x *Result) GetHGETWATCHRes() *HGETWATCHRes { 420 | if x != nil { 421 | if x, ok := x.Response.(*Result_HGETWATCHRes); ok { 422 | return x.HGETWATCHRes 423 | } 424 | } 425 | return nil 426 | } 427 | 428 | func (x *Result) GetHGETALLWATCHRes() *HGETALLWATCHRes { 429 | if x != nil { 430 | if x, ok := x.Response.(*Result_HGETALLWATCHRes); ok { 431 | return x.HGETALLWATCHRes 432 | } 433 | } 434 | return nil 435 | } 436 | 437 | func (x *Result) GetZADDRes() *ZADDRes { 438 | if x != nil { 439 | if x, ok := x.Response.(*Result_ZADDRes); ok { 440 | return x.ZADDRes 441 | } 442 | } 443 | return nil 444 | } 445 | 446 | func (x *Result) GetZCOUNTRes() *ZCOUNTRes { 447 | if x != nil { 448 | if x, ok := x.Response.(*Result_ZCOUNTRes); ok { 449 | return x.ZCOUNTRes 450 | } 451 | } 452 | return nil 453 | } 454 | 455 | func (x *Result) GetZRANGERes() *ZRANGERes { 456 | if x != nil { 457 | if x, ok := x.Response.(*Result_ZRANGERes); ok { 458 | return x.ZRANGERes 459 | } 460 | } 461 | return nil 462 | } 463 | 464 | func (x *Result) GetZPOPMAXRes() *ZPOPMAXRes { 465 | if x != nil { 466 | if x, ok := x.Response.(*Result_ZPOPMAXRes); ok { 467 | return x.ZPOPMAXRes 468 | } 469 | } 470 | return nil 471 | } 472 | 473 | func (x *Result) GetZREMRes() *ZREMRes { 474 | if x != nil { 475 | if x, ok := x.Response.(*Result_ZREMRes); ok { 476 | return x.ZREMRes 477 | } 478 | } 479 | return nil 480 | } 481 | 482 | func (x *Result) GetZPOPMINRes() *ZPOPMINRes { 483 | if x != nil { 484 | if x, ok := x.Response.(*Result_ZPOPMINRes); ok { 485 | return x.ZPOPMINRes 486 | } 487 | } 488 | return nil 489 | } 490 | 491 | func (x *Result) GetZRANKRes() *ZRANKRes { 492 | if x != nil { 493 | if x, ok := x.Response.(*Result_ZRANKRes); ok { 494 | return x.ZRANKRes 495 | } 496 | } 497 | return nil 498 | } 499 | 500 | func (x *Result) GetZCARDRes() *ZCARDRes { 501 | if x != nil { 502 | if x, ok := x.Response.(*Result_ZCARDRes); ok { 503 | return x.ZCARDRes 504 | } 505 | } 506 | return nil 507 | } 508 | 509 | func (x *Result) GetZRANGEWATCHRes() *ZRANGEWATCHRes { 510 | if x != nil { 511 | if x, ok := x.Response.(*Result_ZRANGEWATCHRes); ok { 512 | return x.ZRANGEWATCHRes 513 | } 514 | } 515 | return nil 516 | } 517 | 518 | func (x *Result) GetZCOUNTWATCHRes() *ZCOUNTWATCHRes { 519 | if x != nil { 520 | if x, ok := x.Response.(*Result_ZCOUNTWATCHRes); ok { 521 | return x.ZCOUNTWATCHRes 522 | } 523 | } 524 | return nil 525 | } 526 | 527 | func (x *Result) GetZCARDWATCHRes() *ZCARDWATCHRes { 528 | if x != nil { 529 | if x, ok := x.Response.(*Result_ZCARDWATCHRes); ok { 530 | return x.ZCARDWATCHRes 531 | } 532 | } 533 | return nil 534 | } 535 | 536 | func (x *Result) GetZRANKWATCHRes() *ZRANKWATCHRes { 537 | if x != nil { 538 | if x, ok := x.Response.(*Result_ZRANKWATCHRes); ok { 539 | return x.ZRANKWATCHRes 540 | } 541 | } 542 | return nil 543 | } 544 | 545 | func (x *Result) GetGEOADDRes() *GEOADDRes { 546 | if x != nil { 547 | if x, ok := x.Response.(*Result_GEOADDRes); ok { 548 | return x.GEOADDRes 549 | } 550 | } 551 | return nil 552 | } 553 | 554 | func (x *Result) GetGEODISTRes() *GEODISTRes { 555 | if x != nil { 556 | if x, ok := x.Response.(*Result_GEODISTRes); ok { 557 | return x.GEODISTRes 558 | } 559 | } 560 | return nil 561 | } 562 | 563 | func (x *Result) GetGEOSEARCHRes() *GEOSEARCHRes { 564 | if x != nil { 565 | if x, ok := x.Response.(*Result_GEOSEARCHRes); ok { 566 | return x.GEOSEARCHRes 567 | } 568 | } 569 | return nil 570 | } 571 | 572 | func (x *Result) GetGEOHASHRes() *GEOHASHRes { 573 | if x != nil { 574 | if x, ok := x.Response.(*Result_GEOHASHRes); ok { 575 | return x.GEOHASHRes 576 | } 577 | } 578 | return nil 579 | } 580 | 581 | func (x *Result) GetGEOPOSRes() *GEOPOSRes { 582 | if x != nil { 583 | if x, ok := x.Response.(*Result_GEOPOSRes); ok { 584 | return x.GEOPOSRes 585 | } 586 | } 587 | return nil 588 | } 589 | 590 | type isResult_Response interface { 591 | isResult_Response() 592 | } 593 | 594 | type Result_TYPERes struct { 595 | TYPERes *TYPERes `protobuf:"bytes,11,opt,name=TYPERes,proto3,oneof"` 596 | } 597 | 598 | type Result_PINGRes struct { 599 | PINGRes *PINGRes `protobuf:"bytes,12,opt,name=PINGRes,proto3,oneof"` 600 | } 601 | 602 | type Result_ECHORes struct { 603 | ECHORes *ECHORes `protobuf:"bytes,13,opt,name=ECHORes,proto3,oneof"` 604 | } 605 | 606 | type Result_HANDSHAKERes struct { 607 | HANDSHAKERes *HANDSHAKERes `protobuf:"bytes,14,opt,name=HANDSHAKERes,proto3,oneof"` 608 | } 609 | 610 | type Result_EXISTSRes struct { 611 | EXISTSRes *EXISTSRes `protobuf:"bytes,15,opt,name=EXISTSRes,proto3,oneof"` 612 | } 613 | 614 | type Result_GETRes struct { 615 | GETRes *GETRes `protobuf:"bytes,16,opt,name=GETRes,proto3,oneof"` 616 | } 617 | 618 | type Result_SETRes struct { 619 | SETRes *SETRes `protobuf:"bytes,17,opt,name=SETRes,proto3,oneof"` 620 | } 621 | 622 | type Result_DELRes struct { 623 | DELRes *DELRes `protobuf:"bytes,18,opt,name=DELRes,proto3,oneof"` 624 | } 625 | 626 | type Result_KEYSRes struct { 627 | KEYSRes *KEYSRes `protobuf:"bytes,19,opt,name=KEYSRes,proto3,oneof"` 628 | } 629 | 630 | type Result_GETDELRes struct { 631 | GETDELRes *GETDELRes `protobuf:"bytes,20,opt,name=GETDELRes,proto3,oneof"` 632 | } 633 | 634 | type Result_GETEXRes struct { 635 | GETEXRes *GETEXRes `protobuf:"bytes,21,opt,name=GETEXRes,proto3,oneof"` 636 | } 637 | 638 | type Result_GETSETRes struct { 639 | GETSETRes *GETSETRes `protobuf:"bytes,22,opt,name=GETSETRes,proto3,oneof"` 640 | } 641 | 642 | type Result_INCRRes struct { 643 | INCRRes *INCRRes `protobuf:"bytes,23,opt,name=INCRRes,proto3,oneof"` 644 | } 645 | 646 | type Result_DECRRes struct { 647 | DECRRes *DECRRes `protobuf:"bytes,24,opt,name=DECRRes,proto3,oneof"` 648 | } 649 | 650 | type Result_INCRBYRes struct { 651 | INCRBYRes *INCRBYRes `protobuf:"bytes,25,opt,name=INCRBYRes,proto3,oneof"` 652 | } 653 | 654 | type Result_DECRBYRes struct { 655 | DECRBYRes *DECRBYRes `protobuf:"bytes,26,opt,name=DECRBYRes,proto3,oneof"` 656 | } 657 | 658 | type Result_FLUSHDBRes struct { 659 | FLUSHDBRes *FLUSHDBRes `protobuf:"bytes,27,opt,name=FLUSHDBRes,proto3,oneof"` 660 | } 661 | 662 | type Result_EXPIRERes struct { 663 | EXPIRERes *EXPIRERes `protobuf:"bytes,28,opt,name=EXPIRERes,proto3,oneof"` 664 | } 665 | 666 | type Result_EXPIREATRes struct { 667 | EXPIREATRes *EXPIREATRes `protobuf:"bytes,29,opt,name=EXPIREATRes,proto3,oneof"` 668 | } 669 | 670 | type Result_EXPIRETIMERes struct { 671 | EXPIRETIMERes *EXPIRETIMERes `protobuf:"bytes,30,opt,name=EXPIRETIMERes,proto3,oneof"` 672 | } 673 | 674 | type Result_TTLRes struct { 675 | TTLRes *TTLRes `protobuf:"bytes,31,opt,name=TTLRes,proto3,oneof"` 676 | } 677 | 678 | type Result_GETWATCHRes struct { 679 | GETWATCHRes *GETWATCHRes `protobuf:"bytes,32,opt,name=GETWATCHRes,proto3,oneof"` 680 | } 681 | 682 | type Result_UNWATCHRes struct { 683 | UNWATCHRes *UNWATCHRes `protobuf:"bytes,33,opt,name=UNWATCHRes,proto3,oneof"` 684 | } 685 | 686 | type Result_HGETRes struct { 687 | HGETRes *HGETRes `protobuf:"bytes,34,opt,name=HGETRes,proto3,oneof"` 688 | } 689 | 690 | type Result_HSETRes struct { 691 | HSETRes *HSETRes `protobuf:"bytes,35,opt,name=HSETRes,proto3,oneof"` 692 | } 693 | 694 | type Result_HGETALLRes struct { 695 | HGETALLRes *HGETALLRes `protobuf:"bytes,36,opt,name=HGETALLRes,proto3,oneof"` 696 | } 697 | 698 | type Result_HGETWATCHRes struct { 699 | HGETWATCHRes *HGETWATCHRes `protobuf:"bytes,37,opt,name=HGETWATCHRes,proto3,oneof"` 700 | } 701 | 702 | type Result_HGETALLWATCHRes struct { 703 | HGETALLWATCHRes *HGETALLWATCHRes `protobuf:"bytes,38,opt,name=HGETALLWATCHRes,proto3,oneof"` 704 | } 705 | 706 | type Result_ZADDRes struct { 707 | ZADDRes *ZADDRes `protobuf:"bytes,39,opt,name=ZADDRes,proto3,oneof"` 708 | } 709 | 710 | type Result_ZCOUNTRes struct { 711 | ZCOUNTRes *ZCOUNTRes `protobuf:"bytes,40,opt,name=ZCOUNTRes,proto3,oneof"` 712 | } 713 | 714 | type Result_ZRANGERes struct { 715 | ZRANGERes *ZRANGERes `protobuf:"bytes,41,opt,name=ZRANGERes,proto3,oneof"` 716 | } 717 | 718 | type Result_ZPOPMAXRes struct { 719 | ZPOPMAXRes *ZPOPMAXRes `protobuf:"bytes,42,opt,name=ZPOPMAXRes,proto3,oneof"` 720 | } 721 | 722 | type Result_ZREMRes struct { 723 | ZREMRes *ZREMRes `protobuf:"bytes,43,opt,name=ZREMRes,proto3,oneof"` 724 | } 725 | 726 | type Result_ZPOPMINRes struct { 727 | ZPOPMINRes *ZPOPMINRes `protobuf:"bytes,44,opt,name=ZPOPMINRes,proto3,oneof"` 728 | } 729 | 730 | type Result_ZRANKRes struct { 731 | ZRANKRes *ZRANKRes `protobuf:"bytes,45,opt,name=ZRANKRes,proto3,oneof"` 732 | } 733 | 734 | type Result_ZCARDRes struct { 735 | ZCARDRes *ZCARDRes `protobuf:"bytes,46,opt,name=ZCARDRes,proto3,oneof"` 736 | } 737 | 738 | type Result_ZRANGEWATCHRes struct { 739 | ZRANGEWATCHRes *ZRANGEWATCHRes `protobuf:"bytes,47,opt,name=ZRANGEWATCHRes,proto3,oneof"` 740 | } 741 | 742 | type Result_ZCOUNTWATCHRes struct { 743 | ZCOUNTWATCHRes *ZCOUNTWATCHRes `protobuf:"bytes,48,opt,name=ZCOUNTWATCHRes,proto3,oneof"` 744 | } 745 | 746 | type Result_ZCARDWATCHRes struct { 747 | ZCARDWATCHRes *ZCARDWATCHRes `protobuf:"bytes,49,opt,name=ZCARDWATCHRes,proto3,oneof"` 748 | } 749 | 750 | type Result_ZRANKWATCHRes struct { 751 | ZRANKWATCHRes *ZRANKWATCHRes `protobuf:"bytes,50,opt,name=ZRANKWATCHRes,proto3,oneof"` 752 | } 753 | 754 | type Result_GEOADDRes struct { 755 | GEOADDRes *GEOADDRes `protobuf:"bytes,51,opt,name=GEOADDRes,proto3,oneof"` 756 | } 757 | 758 | type Result_GEODISTRes struct { 759 | GEODISTRes *GEODISTRes `protobuf:"bytes,52,opt,name=GEODISTRes,proto3,oneof"` 760 | } 761 | 762 | type Result_GEOSEARCHRes struct { 763 | GEOSEARCHRes *GEOSEARCHRes `protobuf:"bytes,53,opt,name=GEOSEARCHRes,proto3,oneof"` 764 | } 765 | 766 | type Result_GEOHASHRes struct { 767 | GEOHASHRes *GEOHASHRes `protobuf:"bytes,54,opt,name=GEOHASHRes,proto3,oneof"` 768 | } 769 | 770 | type Result_GEOPOSRes struct { 771 | GEOPOSRes *GEOPOSRes `protobuf:"bytes,55,opt,name=GEOPOSRes,proto3,oneof"` 772 | } 773 | 774 | func (*Result_TYPERes) isResult_Response() {} 775 | 776 | func (*Result_PINGRes) isResult_Response() {} 777 | 778 | func (*Result_ECHORes) isResult_Response() {} 779 | 780 | func (*Result_HANDSHAKERes) isResult_Response() {} 781 | 782 | func (*Result_EXISTSRes) isResult_Response() {} 783 | 784 | func (*Result_GETRes) isResult_Response() {} 785 | 786 | func (*Result_SETRes) isResult_Response() {} 787 | 788 | func (*Result_DELRes) isResult_Response() {} 789 | 790 | func (*Result_KEYSRes) isResult_Response() {} 791 | 792 | func (*Result_GETDELRes) isResult_Response() {} 793 | 794 | func (*Result_GETEXRes) isResult_Response() {} 795 | 796 | func (*Result_GETSETRes) isResult_Response() {} 797 | 798 | func (*Result_INCRRes) isResult_Response() {} 799 | 800 | func (*Result_DECRRes) isResult_Response() {} 801 | 802 | func (*Result_INCRBYRes) isResult_Response() {} 803 | 804 | func (*Result_DECRBYRes) isResult_Response() {} 805 | 806 | func (*Result_FLUSHDBRes) isResult_Response() {} 807 | 808 | func (*Result_EXPIRERes) isResult_Response() {} 809 | 810 | func (*Result_EXPIREATRes) isResult_Response() {} 811 | 812 | func (*Result_EXPIRETIMERes) isResult_Response() {} 813 | 814 | func (*Result_TTLRes) isResult_Response() {} 815 | 816 | func (*Result_GETWATCHRes) isResult_Response() {} 817 | 818 | func (*Result_UNWATCHRes) isResult_Response() {} 819 | 820 | func (*Result_HGETRes) isResult_Response() {} 821 | 822 | func (*Result_HSETRes) isResult_Response() {} 823 | 824 | func (*Result_HGETALLRes) isResult_Response() {} 825 | 826 | func (*Result_HGETWATCHRes) isResult_Response() {} 827 | 828 | func (*Result_HGETALLWATCHRes) isResult_Response() {} 829 | 830 | func (*Result_ZADDRes) isResult_Response() {} 831 | 832 | func (*Result_ZCOUNTRes) isResult_Response() {} 833 | 834 | func (*Result_ZRANGERes) isResult_Response() {} 835 | 836 | func (*Result_ZPOPMAXRes) isResult_Response() {} 837 | 838 | func (*Result_ZREMRes) isResult_Response() {} 839 | 840 | func (*Result_ZPOPMINRes) isResult_Response() {} 841 | 842 | func (*Result_ZRANKRes) isResult_Response() {} 843 | 844 | func (*Result_ZCARDRes) isResult_Response() {} 845 | 846 | func (*Result_ZRANGEWATCHRes) isResult_Response() {} 847 | 848 | func (*Result_ZCOUNTWATCHRes) isResult_Response() {} 849 | 850 | func (*Result_ZCARDWATCHRes) isResult_Response() {} 851 | 852 | func (*Result_ZRANKWATCHRes) isResult_Response() {} 853 | 854 | func (*Result_GEOADDRes) isResult_Response() {} 855 | 856 | func (*Result_GEODISTRes) isResult_Response() {} 857 | 858 | func (*Result_GEOSEARCHRes) isResult_Response() {} 859 | 860 | func (*Result_GEOHASHRes) isResult_Response() {} 861 | 862 | func (*Result_GEOPOSRes) isResult_Response() {} 863 | 864 | type ZRANKWATCHRes struct { 865 | state protoimpl.MessageState `protogen:"open.v1"` 866 | unknownFields protoimpl.UnknownFields 867 | sizeCache protoimpl.SizeCache 868 | } 869 | 870 | func (x *ZRANKWATCHRes) Reset() { 871 | *x = ZRANKWATCHRes{} 872 | mi := &file_protos_res_proto_msgTypes[1] 873 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 874 | ms.StoreMessageInfo(mi) 875 | } 876 | 877 | func (x *ZRANKWATCHRes) String() string { 878 | return protoimpl.X.MessageStringOf(x) 879 | } 880 | 881 | func (*ZRANKWATCHRes) ProtoMessage() {} 882 | 883 | func (x *ZRANKWATCHRes) ProtoReflect() protoreflect.Message { 884 | mi := &file_protos_res_proto_msgTypes[1] 885 | if x != nil { 886 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 887 | if ms.LoadMessageInfo() == nil { 888 | ms.StoreMessageInfo(mi) 889 | } 890 | return ms 891 | } 892 | return mi.MessageOf(x) 893 | } 894 | 895 | // Deprecated: Use ZRANKWATCHRes.ProtoReflect.Descriptor instead. 896 | func (*ZRANKWATCHRes) Descriptor() ([]byte, []int) { 897 | return file_protos_res_proto_rawDescGZIP(), []int{1} 898 | } 899 | 900 | type HGETWATCHRes struct { 901 | state protoimpl.MessageState `protogen:"open.v1"` 902 | unknownFields protoimpl.UnknownFields 903 | sizeCache protoimpl.SizeCache 904 | } 905 | 906 | func (x *HGETWATCHRes) Reset() { 907 | *x = HGETWATCHRes{} 908 | mi := &file_protos_res_proto_msgTypes[2] 909 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 910 | ms.StoreMessageInfo(mi) 911 | } 912 | 913 | func (x *HGETWATCHRes) String() string { 914 | return protoimpl.X.MessageStringOf(x) 915 | } 916 | 917 | func (*HGETWATCHRes) ProtoMessage() {} 918 | 919 | func (x *HGETWATCHRes) ProtoReflect() protoreflect.Message { 920 | mi := &file_protos_res_proto_msgTypes[2] 921 | if x != nil { 922 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 923 | if ms.LoadMessageInfo() == nil { 924 | ms.StoreMessageInfo(mi) 925 | } 926 | return ms 927 | } 928 | return mi.MessageOf(x) 929 | } 930 | 931 | // Deprecated: Use HGETWATCHRes.ProtoReflect.Descriptor instead. 932 | func (*HGETWATCHRes) Descriptor() ([]byte, []int) { 933 | return file_protos_res_proto_rawDescGZIP(), []int{2} 934 | } 935 | 936 | type HGETALLWATCHRes struct { 937 | state protoimpl.MessageState `protogen:"open.v1"` 938 | unknownFields protoimpl.UnknownFields 939 | sizeCache protoimpl.SizeCache 940 | } 941 | 942 | func (x *HGETALLWATCHRes) Reset() { 943 | *x = HGETALLWATCHRes{} 944 | mi := &file_protos_res_proto_msgTypes[3] 945 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 946 | ms.StoreMessageInfo(mi) 947 | } 948 | 949 | func (x *HGETALLWATCHRes) String() string { 950 | return protoimpl.X.MessageStringOf(x) 951 | } 952 | 953 | func (*HGETALLWATCHRes) ProtoMessage() {} 954 | 955 | func (x *HGETALLWATCHRes) ProtoReflect() protoreflect.Message { 956 | mi := &file_protos_res_proto_msgTypes[3] 957 | if x != nil { 958 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 959 | if ms.LoadMessageInfo() == nil { 960 | ms.StoreMessageInfo(mi) 961 | } 962 | return ms 963 | } 964 | return mi.MessageOf(x) 965 | } 966 | 967 | // Deprecated: Use HGETALLWATCHRes.ProtoReflect.Descriptor instead. 968 | func (*HGETALLWATCHRes) Descriptor() ([]byte, []int) { 969 | return file_protos_res_proto_rawDescGZIP(), []int{3} 970 | } 971 | 972 | type GETWATCHRes struct { 973 | state protoimpl.MessageState `protogen:"open.v1"` 974 | unknownFields protoimpl.UnknownFields 975 | sizeCache protoimpl.SizeCache 976 | } 977 | 978 | func (x *GETWATCHRes) Reset() { 979 | *x = GETWATCHRes{} 980 | mi := &file_protos_res_proto_msgTypes[4] 981 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 982 | ms.StoreMessageInfo(mi) 983 | } 984 | 985 | func (x *GETWATCHRes) String() string { 986 | return protoimpl.X.MessageStringOf(x) 987 | } 988 | 989 | func (*GETWATCHRes) ProtoMessage() {} 990 | 991 | func (x *GETWATCHRes) ProtoReflect() protoreflect.Message { 992 | mi := &file_protos_res_proto_msgTypes[4] 993 | if x != nil { 994 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 995 | if ms.LoadMessageInfo() == nil { 996 | ms.StoreMessageInfo(mi) 997 | } 998 | return ms 999 | } 1000 | return mi.MessageOf(x) 1001 | } 1002 | 1003 | // Deprecated: Use GETWATCHRes.ProtoReflect.Descriptor instead. 1004 | func (*GETWATCHRes) Descriptor() ([]byte, []int) { 1005 | return file_protos_res_proto_rawDescGZIP(), []int{4} 1006 | } 1007 | 1008 | type UNWATCHRes struct { 1009 | state protoimpl.MessageState `protogen:"open.v1"` 1010 | unknownFields protoimpl.UnknownFields 1011 | sizeCache protoimpl.SizeCache 1012 | } 1013 | 1014 | func (x *UNWATCHRes) Reset() { 1015 | *x = UNWATCHRes{} 1016 | mi := &file_protos_res_proto_msgTypes[5] 1017 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1018 | ms.StoreMessageInfo(mi) 1019 | } 1020 | 1021 | func (x *UNWATCHRes) String() string { 1022 | return protoimpl.X.MessageStringOf(x) 1023 | } 1024 | 1025 | func (*UNWATCHRes) ProtoMessage() {} 1026 | 1027 | func (x *UNWATCHRes) ProtoReflect() protoreflect.Message { 1028 | mi := &file_protos_res_proto_msgTypes[5] 1029 | if x != nil { 1030 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1031 | if ms.LoadMessageInfo() == nil { 1032 | ms.StoreMessageInfo(mi) 1033 | } 1034 | return ms 1035 | } 1036 | return mi.MessageOf(x) 1037 | } 1038 | 1039 | // Deprecated: Use UNWATCHRes.ProtoReflect.Descriptor instead. 1040 | func (*UNWATCHRes) Descriptor() ([]byte, []int) { 1041 | return file_protos_res_proto_rawDescGZIP(), []int{5} 1042 | } 1043 | 1044 | type ZADDRes struct { 1045 | state protoimpl.MessageState `protogen:"open.v1"` 1046 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 1047 | unknownFields protoimpl.UnknownFields 1048 | sizeCache protoimpl.SizeCache 1049 | } 1050 | 1051 | func (x *ZADDRes) Reset() { 1052 | *x = ZADDRes{} 1053 | mi := &file_protos_res_proto_msgTypes[6] 1054 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1055 | ms.StoreMessageInfo(mi) 1056 | } 1057 | 1058 | func (x *ZADDRes) String() string { 1059 | return protoimpl.X.MessageStringOf(x) 1060 | } 1061 | 1062 | func (*ZADDRes) ProtoMessage() {} 1063 | 1064 | func (x *ZADDRes) ProtoReflect() protoreflect.Message { 1065 | mi := &file_protos_res_proto_msgTypes[6] 1066 | if x != nil { 1067 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1068 | if ms.LoadMessageInfo() == nil { 1069 | ms.StoreMessageInfo(mi) 1070 | } 1071 | return ms 1072 | } 1073 | return mi.MessageOf(x) 1074 | } 1075 | 1076 | // Deprecated: Use ZADDRes.ProtoReflect.Descriptor instead. 1077 | func (*ZADDRes) Descriptor() ([]byte, []int) { 1078 | return file_protos_res_proto_rawDescGZIP(), []int{6} 1079 | } 1080 | 1081 | func (x *ZADDRes) GetCount() int64 { 1082 | if x != nil { 1083 | return x.Count 1084 | } 1085 | return 0 1086 | } 1087 | 1088 | type ZCOUNTRes struct { 1089 | state protoimpl.MessageState `protogen:"open.v1"` 1090 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 1091 | unknownFields protoimpl.UnknownFields 1092 | sizeCache protoimpl.SizeCache 1093 | } 1094 | 1095 | func (x *ZCOUNTRes) Reset() { 1096 | *x = ZCOUNTRes{} 1097 | mi := &file_protos_res_proto_msgTypes[7] 1098 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1099 | ms.StoreMessageInfo(mi) 1100 | } 1101 | 1102 | func (x *ZCOUNTRes) String() string { 1103 | return protoimpl.X.MessageStringOf(x) 1104 | } 1105 | 1106 | func (*ZCOUNTRes) ProtoMessage() {} 1107 | 1108 | func (x *ZCOUNTRes) ProtoReflect() protoreflect.Message { 1109 | mi := &file_protos_res_proto_msgTypes[7] 1110 | if x != nil { 1111 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1112 | if ms.LoadMessageInfo() == nil { 1113 | ms.StoreMessageInfo(mi) 1114 | } 1115 | return ms 1116 | } 1117 | return mi.MessageOf(x) 1118 | } 1119 | 1120 | // Deprecated: Use ZCOUNTRes.ProtoReflect.Descriptor instead. 1121 | func (*ZCOUNTRes) Descriptor() ([]byte, []int) { 1122 | return file_protos_res_proto_rawDescGZIP(), []int{7} 1123 | } 1124 | 1125 | func (x *ZCOUNTRes) GetCount() int64 { 1126 | if x != nil { 1127 | return x.Count 1128 | } 1129 | return 0 1130 | } 1131 | 1132 | type TYPERes struct { 1133 | state protoimpl.MessageState `protogen:"open.v1"` 1134 | Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` 1135 | unknownFields protoimpl.UnknownFields 1136 | sizeCache protoimpl.SizeCache 1137 | } 1138 | 1139 | func (x *TYPERes) Reset() { 1140 | *x = TYPERes{} 1141 | mi := &file_protos_res_proto_msgTypes[8] 1142 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1143 | ms.StoreMessageInfo(mi) 1144 | } 1145 | 1146 | func (x *TYPERes) String() string { 1147 | return protoimpl.X.MessageStringOf(x) 1148 | } 1149 | 1150 | func (*TYPERes) ProtoMessage() {} 1151 | 1152 | func (x *TYPERes) ProtoReflect() protoreflect.Message { 1153 | mi := &file_protos_res_proto_msgTypes[8] 1154 | if x != nil { 1155 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1156 | if ms.LoadMessageInfo() == nil { 1157 | ms.StoreMessageInfo(mi) 1158 | } 1159 | return ms 1160 | } 1161 | return mi.MessageOf(x) 1162 | } 1163 | 1164 | // Deprecated: Use TYPERes.ProtoReflect.Descriptor instead. 1165 | func (*TYPERes) Descriptor() ([]byte, []int) { 1166 | return file_protos_res_proto_rawDescGZIP(), []int{8} 1167 | } 1168 | 1169 | func (x *TYPERes) GetType() string { 1170 | if x != nil { 1171 | return x.Type 1172 | } 1173 | return "" 1174 | } 1175 | 1176 | type PINGRes struct { 1177 | state protoimpl.MessageState `protogen:"open.v1"` 1178 | Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` 1179 | unknownFields protoimpl.UnknownFields 1180 | sizeCache protoimpl.SizeCache 1181 | } 1182 | 1183 | func (x *PINGRes) Reset() { 1184 | *x = PINGRes{} 1185 | mi := &file_protos_res_proto_msgTypes[9] 1186 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1187 | ms.StoreMessageInfo(mi) 1188 | } 1189 | 1190 | func (x *PINGRes) String() string { 1191 | return protoimpl.X.MessageStringOf(x) 1192 | } 1193 | 1194 | func (*PINGRes) ProtoMessage() {} 1195 | 1196 | func (x *PINGRes) ProtoReflect() protoreflect.Message { 1197 | mi := &file_protos_res_proto_msgTypes[9] 1198 | if x != nil { 1199 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1200 | if ms.LoadMessageInfo() == nil { 1201 | ms.StoreMessageInfo(mi) 1202 | } 1203 | return ms 1204 | } 1205 | return mi.MessageOf(x) 1206 | } 1207 | 1208 | // Deprecated: Use PINGRes.ProtoReflect.Descriptor instead. 1209 | func (*PINGRes) Descriptor() ([]byte, []int) { 1210 | return file_protos_res_proto_rawDescGZIP(), []int{9} 1211 | } 1212 | 1213 | func (x *PINGRes) GetMessage() string { 1214 | if x != nil { 1215 | return x.Message 1216 | } 1217 | return "" 1218 | } 1219 | 1220 | type HGETRes struct { 1221 | state protoimpl.MessageState `protogen:"open.v1"` 1222 | Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 1223 | unknownFields protoimpl.UnknownFields 1224 | sizeCache protoimpl.SizeCache 1225 | } 1226 | 1227 | func (x *HGETRes) Reset() { 1228 | *x = HGETRes{} 1229 | mi := &file_protos_res_proto_msgTypes[10] 1230 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1231 | ms.StoreMessageInfo(mi) 1232 | } 1233 | 1234 | func (x *HGETRes) String() string { 1235 | return protoimpl.X.MessageStringOf(x) 1236 | } 1237 | 1238 | func (*HGETRes) ProtoMessage() {} 1239 | 1240 | func (x *HGETRes) ProtoReflect() protoreflect.Message { 1241 | mi := &file_protos_res_proto_msgTypes[10] 1242 | if x != nil { 1243 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1244 | if ms.LoadMessageInfo() == nil { 1245 | ms.StoreMessageInfo(mi) 1246 | } 1247 | return ms 1248 | } 1249 | return mi.MessageOf(x) 1250 | } 1251 | 1252 | // Deprecated: Use HGETRes.ProtoReflect.Descriptor instead. 1253 | func (*HGETRes) Descriptor() ([]byte, []int) { 1254 | return file_protos_res_proto_rawDescGZIP(), []int{10} 1255 | } 1256 | 1257 | func (x *HGETRes) GetValue() string { 1258 | if x != nil { 1259 | return x.Value 1260 | } 1261 | return "" 1262 | } 1263 | 1264 | type HSETRes struct { 1265 | state protoimpl.MessageState `protogen:"open.v1"` 1266 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 1267 | unknownFields protoimpl.UnknownFields 1268 | sizeCache protoimpl.SizeCache 1269 | } 1270 | 1271 | func (x *HSETRes) Reset() { 1272 | *x = HSETRes{} 1273 | mi := &file_protos_res_proto_msgTypes[11] 1274 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1275 | ms.StoreMessageInfo(mi) 1276 | } 1277 | 1278 | func (x *HSETRes) String() string { 1279 | return protoimpl.X.MessageStringOf(x) 1280 | } 1281 | 1282 | func (*HSETRes) ProtoMessage() {} 1283 | 1284 | func (x *HSETRes) ProtoReflect() protoreflect.Message { 1285 | mi := &file_protos_res_proto_msgTypes[11] 1286 | if x != nil { 1287 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1288 | if ms.LoadMessageInfo() == nil { 1289 | ms.StoreMessageInfo(mi) 1290 | } 1291 | return ms 1292 | } 1293 | return mi.MessageOf(x) 1294 | } 1295 | 1296 | // Deprecated: Use HSETRes.ProtoReflect.Descriptor instead. 1297 | func (*HSETRes) Descriptor() ([]byte, []int) { 1298 | return file_protos_res_proto_rawDescGZIP(), []int{11} 1299 | } 1300 | 1301 | func (x *HSETRes) GetCount() int64 { 1302 | if x != nil { 1303 | return x.Count 1304 | } 1305 | return 0 1306 | } 1307 | 1308 | type HElement struct { 1309 | state protoimpl.MessageState `protogen:"open.v1"` 1310 | Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` 1311 | Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` 1312 | unknownFields protoimpl.UnknownFields 1313 | sizeCache protoimpl.SizeCache 1314 | } 1315 | 1316 | func (x *HElement) Reset() { 1317 | *x = HElement{} 1318 | mi := &file_protos_res_proto_msgTypes[12] 1319 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1320 | ms.StoreMessageInfo(mi) 1321 | } 1322 | 1323 | func (x *HElement) String() string { 1324 | return protoimpl.X.MessageStringOf(x) 1325 | } 1326 | 1327 | func (*HElement) ProtoMessage() {} 1328 | 1329 | func (x *HElement) ProtoReflect() protoreflect.Message { 1330 | mi := &file_protos_res_proto_msgTypes[12] 1331 | if x != nil { 1332 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1333 | if ms.LoadMessageInfo() == nil { 1334 | ms.StoreMessageInfo(mi) 1335 | } 1336 | return ms 1337 | } 1338 | return mi.MessageOf(x) 1339 | } 1340 | 1341 | // Deprecated: Use HElement.ProtoReflect.Descriptor instead. 1342 | func (*HElement) Descriptor() ([]byte, []int) { 1343 | return file_protos_res_proto_rawDescGZIP(), []int{12} 1344 | } 1345 | 1346 | func (x *HElement) GetKey() string { 1347 | if x != nil { 1348 | return x.Key 1349 | } 1350 | return "" 1351 | } 1352 | 1353 | func (x *HElement) GetValue() string { 1354 | if x != nil { 1355 | return x.Value 1356 | } 1357 | return "" 1358 | } 1359 | 1360 | type HGETALLRes struct { 1361 | state protoimpl.MessageState `protogen:"open.v1"` 1362 | Elements []*HElement `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"` 1363 | unknownFields protoimpl.UnknownFields 1364 | sizeCache protoimpl.SizeCache 1365 | } 1366 | 1367 | func (x *HGETALLRes) Reset() { 1368 | *x = HGETALLRes{} 1369 | mi := &file_protos_res_proto_msgTypes[13] 1370 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1371 | ms.StoreMessageInfo(mi) 1372 | } 1373 | 1374 | func (x *HGETALLRes) String() string { 1375 | return protoimpl.X.MessageStringOf(x) 1376 | } 1377 | 1378 | func (*HGETALLRes) ProtoMessage() {} 1379 | 1380 | func (x *HGETALLRes) ProtoReflect() protoreflect.Message { 1381 | mi := &file_protos_res_proto_msgTypes[13] 1382 | if x != nil { 1383 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1384 | if ms.LoadMessageInfo() == nil { 1385 | ms.StoreMessageInfo(mi) 1386 | } 1387 | return ms 1388 | } 1389 | return mi.MessageOf(x) 1390 | } 1391 | 1392 | // Deprecated: Use HGETALLRes.ProtoReflect.Descriptor instead. 1393 | func (*HGETALLRes) Descriptor() ([]byte, []int) { 1394 | return file_protos_res_proto_rawDescGZIP(), []int{13} 1395 | } 1396 | 1397 | func (x *HGETALLRes) GetElements() []*HElement { 1398 | if x != nil { 1399 | return x.Elements 1400 | } 1401 | return nil 1402 | } 1403 | 1404 | type TTLRes struct { 1405 | state protoimpl.MessageState `protogen:"open.v1"` 1406 | Seconds int64 `protobuf:"varint,1,opt,name=seconds,proto3" json:"seconds,omitempty"` 1407 | unknownFields protoimpl.UnknownFields 1408 | sizeCache protoimpl.SizeCache 1409 | } 1410 | 1411 | func (x *TTLRes) Reset() { 1412 | *x = TTLRes{} 1413 | mi := &file_protos_res_proto_msgTypes[14] 1414 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1415 | ms.StoreMessageInfo(mi) 1416 | } 1417 | 1418 | func (x *TTLRes) String() string { 1419 | return protoimpl.X.MessageStringOf(x) 1420 | } 1421 | 1422 | func (*TTLRes) ProtoMessage() {} 1423 | 1424 | func (x *TTLRes) ProtoReflect() protoreflect.Message { 1425 | mi := &file_protos_res_proto_msgTypes[14] 1426 | if x != nil { 1427 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1428 | if ms.LoadMessageInfo() == nil { 1429 | ms.StoreMessageInfo(mi) 1430 | } 1431 | return ms 1432 | } 1433 | return mi.MessageOf(x) 1434 | } 1435 | 1436 | // Deprecated: Use TTLRes.ProtoReflect.Descriptor instead. 1437 | func (*TTLRes) Descriptor() ([]byte, []int) { 1438 | return file_protos_res_proto_rawDescGZIP(), []int{14} 1439 | } 1440 | 1441 | func (x *TTLRes) GetSeconds() int64 { 1442 | if x != nil { 1443 | return x.Seconds 1444 | } 1445 | return 0 1446 | } 1447 | 1448 | type EXPIRERes struct { 1449 | state protoimpl.MessageState `protogen:"open.v1"` 1450 | IsChanged bool `protobuf:"varint,1,opt,name=is_changed,json=isChanged,proto3" json:"is_changed,omitempty"` 1451 | unknownFields protoimpl.UnknownFields 1452 | sizeCache protoimpl.SizeCache 1453 | } 1454 | 1455 | func (x *EXPIRERes) Reset() { 1456 | *x = EXPIRERes{} 1457 | mi := &file_protos_res_proto_msgTypes[15] 1458 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1459 | ms.StoreMessageInfo(mi) 1460 | } 1461 | 1462 | func (x *EXPIRERes) String() string { 1463 | return protoimpl.X.MessageStringOf(x) 1464 | } 1465 | 1466 | func (*EXPIRERes) ProtoMessage() {} 1467 | 1468 | func (x *EXPIRERes) ProtoReflect() protoreflect.Message { 1469 | mi := &file_protos_res_proto_msgTypes[15] 1470 | if x != nil { 1471 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1472 | if ms.LoadMessageInfo() == nil { 1473 | ms.StoreMessageInfo(mi) 1474 | } 1475 | return ms 1476 | } 1477 | return mi.MessageOf(x) 1478 | } 1479 | 1480 | // Deprecated: Use EXPIRERes.ProtoReflect.Descriptor instead. 1481 | func (*EXPIRERes) Descriptor() ([]byte, []int) { 1482 | return file_protos_res_proto_rawDescGZIP(), []int{15} 1483 | } 1484 | 1485 | func (x *EXPIRERes) GetIsChanged() bool { 1486 | if x != nil { 1487 | return x.IsChanged 1488 | } 1489 | return false 1490 | } 1491 | 1492 | type EXPIREATRes struct { 1493 | state protoimpl.MessageState `protogen:"open.v1"` 1494 | IsChanged bool `protobuf:"varint,1,opt,name=is_changed,json=isChanged,proto3" json:"is_changed,omitempty"` 1495 | unknownFields protoimpl.UnknownFields 1496 | sizeCache protoimpl.SizeCache 1497 | } 1498 | 1499 | func (x *EXPIREATRes) Reset() { 1500 | *x = EXPIREATRes{} 1501 | mi := &file_protos_res_proto_msgTypes[16] 1502 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1503 | ms.StoreMessageInfo(mi) 1504 | } 1505 | 1506 | func (x *EXPIREATRes) String() string { 1507 | return protoimpl.X.MessageStringOf(x) 1508 | } 1509 | 1510 | func (*EXPIREATRes) ProtoMessage() {} 1511 | 1512 | func (x *EXPIREATRes) ProtoReflect() protoreflect.Message { 1513 | mi := &file_protos_res_proto_msgTypes[16] 1514 | if x != nil { 1515 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1516 | if ms.LoadMessageInfo() == nil { 1517 | ms.StoreMessageInfo(mi) 1518 | } 1519 | return ms 1520 | } 1521 | return mi.MessageOf(x) 1522 | } 1523 | 1524 | // Deprecated: Use EXPIREATRes.ProtoReflect.Descriptor instead. 1525 | func (*EXPIREATRes) Descriptor() ([]byte, []int) { 1526 | return file_protos_res_proto_rawDescGZIP(), []int{16} 1527 | } 1528 | 1529 | func (x *EXPIREATRes) GetIsChanged() bool { 1530 | if x != nil { 1531 | return x.IsChanged 1532 | } 1533 | return false 1534 | } 1535 | 1536 | type EXPIRETIMERes struct { 1537 | state protoimpl.MessageState `protogen:"open.v1"` 1538 | UnixSec int64 `protobuf:"varint,1,opt,name=unix_sec,json=unixSec,proto3" json:"unix_sec,omitempty"` 1539 | unknownFields protoimpl.UnknownFields 1540 | sizeCache protoimpl.SizeCache 1541 | } 1542 | 1543 | func (x *EXPIRETIMERes) Reset() { 1544 | *x = EXPIRETIMERes{} 1545 | mi := &file_protos_res_proto_msgTypes[17] 1546 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1547 | ms.StoreMessageInfo(mi) 1548 | } 1549 | 1550 | func (x *EXPIRETIMERes) String() string { 1551 | return protoimpl.X.MessageStringOf(x) 1552 | } 1553 | 1554 | func (*EXPIRETIMERes) ProtoMessage() {} 1555 | 1556 | func (x *EXPIRETIMERes) ProtoReflect() protoreflect.Message { 1557 | mi := &file_protos_res_proto_msgTypes[17] 1558 | if x != nil { 1559 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1560 | if ms.LoadMessageInfo() == nil { 1561 | ms.StoreMessageInfo(mi) 1562 | } 1563 | return ms 1564 | } 1565 | return mi.MessageOf(x) 1566 | } 1567 | 1568 | // Deprecated: Use EXPIRETIMERes.ProtoReflect.Descriptor instead. 1569 | func (*EXPIRETIMERes) Descriptor() ([]byte, []int) { 1570 | return file_protos_res_proto_rawDescGZIP(), []int{17} 1571 | } 1572 | 1573 | func (x *EXPIRETIMERes) GetUnixSec() int64 { 1574 | if x != nil { 1575 | return x.UnixSec 1576 | } 1577 | return 0 1578 | } 1579 | 1580 | type ECHORes struct { 1581 | state protoimpl.MessageState `protogen:"open.v1"` 1582 | Message string `protobuf:"bytes,1,opt,name=message,proto3" json:"message,omitempty"` 1583 | unknownFields protoimpl.UnknownFields 1584 | sizeCache protoimpl.SizeCache 1585 | } 1586 | 1587 | func (x *ECHORes) Reset() { 1588 | *x = ECHORes{} 1589 | mi := &file_protos_res_proto_msgTypes[18] 1590 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1591 | ms.StoreMessageInfo(mi) 1592 | } 1593 | 1594 | func (x *ECHORes) String() string { 1595 | return protoimpl.X.MessageStringOf(x) 1596 | } 1597 | 1598 | func (*ECHORes) ProtoMessage() {} 1599 | 1600 | func (x *ECHORes) ProtoReflect() protoreflect.Message { 1601 | mi := &file_protos_res_proto_msgTypes[18] 1602 | if x != nil { 1603 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1604 | if ms.LoadMessageInfo() == nil { 1605 | ms.StoreMessageInfo(mi) 1606 | } 1607 | return ms 1608 | } 1609 | return mi.MessageOf(x) 1610 | } 1611 | 1612 | // Deprecated: Use ECHORes.ProtoReflect.Descriptor instead. 1613 | func (*ECHORes) Descriptor() ([]byte, []int) { 1614 | return file_protos_res_proto_rawDescGZIP(), []int{18} 1615 | } 1616 | 1617 | func (x *ECHORes) GetMessage() string { 1618 | if x != nil { 1619 | return x.Message 1620 | } 1621 | return "" 1622 | } 1623 | 1624 | type EXISTSRes struct { 1625 | state protoimpl.MessageState `protogen:"open.v1"` 1626 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 1627 | unknownFields protoimpl.UnknownFields 1628 | sizeCache protoimpl.SizeCache 1629 | } 1630 | 1631 | func (x *EXISTSRes) Reset() { 1632 | *x = EXISTSRes{} 1633 | mi := &file_protos_res_proto_msgTypes[19] 1634 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1635 | ms.StoreMessageInfo(mi) 1636 | } 1637 | 1638 | func (x *EXISTSRes) String() string { 1639 | return protoimpl.X.MessageStringOf(x) 1640 | } 1641 | 1642 | func (*EXISTSRes) ProtoMessage() {} 1643 | 1644 | func (x *EXISTSRes) ProtoReflect() protoreflect.Message { 1645 | mi := &file_protos_res_proto_msgTypes[19] 1646 | if x != nil { 1647 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1648 | if ms.LoadMessageInfo() == nil { 1649 | ms.StoreMessageInfo(mi) 1650 | } 1651 | return ms 1652 | } 1653 | return mi.MessageOf(x) 1654 | } 1655 | 1656 | // Deprecated: Use EXISTSRes.ProtoReflect.Descriptor instead. 1657 | func (*EXISTSRes) Descriptor() ([]byte, []int) { 1658 | return file_protos_res_proto_rawDescGZIP(), []int{19} 1659 | } 1660 | 1661 | func (x *EXISTSRes) GetCount() int64 { 1662 | if x != nil { 1663 | return x.Count 1664 | } 1665 | return 0 1666 | } 1667 | 1668 | type HANDSHAKERes struct { 1669 | state protoimpl.MessageState `protogen:"open.v1"` 1670 | unknownFields protoimpl.UnknownFields 1671 | sizeCache protoimpl.SizeCache 1672 | } 1673 | 1674 | func (x *HANDSHAKERes) Reset() { 1675 | *x = HANDSHAKERes{} 1676 | mi := &file_protos_res_proto_msgTypes[20] 1677 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1678 | ms.StoreMessageInfo(mi) 1679 | } 1680 | 1681 | func (x *HANDSHAKERes) String() string { 1682 | return protoimpl.X.MessageStringOf(x) 1683 | } 1684 | 1685 | func (*HANDSHAKERes) ProtoMessage() {} 1686 | 1687 | func (x *HANDSHAKERes) ProtoReflect() protoreflect.Message { 1688 | mi := &file_protos_res_proto_msgTypes[20] 1689 | if x != nil { 1690 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1691 | if ms.LoadMessageInfo() == nil { 1692 | ms.StoreMessageInfo(mi) 1693 | } 1694 | return ms 1695 | } 1696 | return mi.MessageOf(x) 1697 | } 1698 | 1699 | // Deprecated: Use HANDSHAKERes.ProtoReflect.Descriptor instead. 1700 | func (*HANDSHAKERes) Descriptor() ([]byte, []int) { 1701 | return file_protos_res_proto_rawDescGZIP(), []int{20} 1702 | } 1703 | 1704 | type GETRes struct { 1705 | state protoimpl.MessageState `protogen:"open.v1"` 1706 | Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 1707 | unknownFields protoimpl.UnknownFields 1708 | sizeCache protoimpl.SizeCache 1709 | } 1710 | 1711 | func (x *GETRes) Reset() { 1712 | *x = GETRes{} 1713 | mi := &file_protos_res_proto_msgTypes[21] 1714 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1715 | ms.StoreMessageInfo(mi) 1716 | } 1717 | 1718 | func (x *GETRes) String() string { 1719 | return protoimpl.X.MessageStringOf(x) 1720 | } 1721 | 1722 | func (*GETRes) ProtoMessage() {} 1723 | 1724 | func (x *GETRes) ProtoReflect() protoreflect.Message { 1725 | mi := &file_protos_res_proto_msgTypes[21] 1726 | if x != nil { 1727 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1728 | if ms.LoadMessageInfo() == nil { 1729 | ms.StoreMessageInfo(mi) 1730 | } 1731 | return ms 1732 | } 1733 | return mi.MessageOf(x) 1734 | } 1735 | 1736 | // Deprecated: Use GETRes.ProtoReflect.Descriptor instead. 1737 | func (*GETRes) Descriptor() ([]byte, []int) { 1738 | return file_protos_res_proto_rawDescGZIP(), []int{21} 1739 | } 1740 | 1741 | func (x *GETRes) GetValue() string { 1742 | if x != nil { 1743 | return x.Value 1744 | } 1745 | return "" 1746 | } 1747 | 1748 | type GETEXRes struct { 1749 | state protoimpl.MessageState `protogen:"open.v1"` 1750 | Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 1751 | unknownFields protoimpl.UnknownFields 1752 | sizeCache protoimpl.SizeCache 1753 | } 1754 | 1755 | func (x *GETEXRes) Reset() { 1756 | *x = GETEXRes{} 1757 | mi := &file_protos_res_proto_msgTypes[22] 1758 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1759 | ms.StoreMessageInfo(mi) 1760 | } 1761 | 1762 | func (x *GETEXRes) String() string { 1763 | return protoimpl.X.MessageStringOf(x) 1764 | } 1765 | 1766 | func (*GETEXRes) ProtoMessage() {} 1767 | 1768 | func (x *GETEXRes) ProtoReflect() protoreflect.Message { 1769 | mi := &file_protos_res_proto_msgTypes[22] 1770 | if x != nil { 1771 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1772 | if ms.LoadMessageInfo() == nil { 1773 | ms.StoreMessageInfo(mi) 1774 | } 1775 | return ms 1776 | } 1777 | return mi.MessageOf(x) 1778 | } 1779 | 1780 | // Deprecated: Use GETEXRes.ProtoReflect.Descriptor instead. 1781 | func (*GETEXRes) Descriptor() ([]byte, []int) { 1782 | return file_protos_res_proto_rawDescGZIP(), []int{22} 1783 | } 1784 | 1785 | func (x *GETEXRes) GetValue() string { 1786 | if x != nil { 1787 | return x.Value 1788 | } 1789 | return "" 1790 | } 1791 | 1792 | type GETSETRes struct { 1793 | state protoimpl.MessageState `protogen:"open.v1"` 1794 | Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 1795 | unknownFields protoimpl.UnknownFields 1796 | sizeCache protoimpl.SizeCache 1797 | } 1798 | 1799 | func (x *GETSETRes) Reset() { 1800 | *x = GETSETRes{} 1801 | mi := &file_protos_res_proto_msgTypes[23] 1802 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1803 | ms.StoreMessageInfo(mi) 1804 | } 1805 | 1806 | func (x *GETSETRes) String() string { 1807 | return protoimpl.X.MessageStringOf(x) 1808 | } 1809 | 1810 | func (*GETSETRes) ProtoMessage() {} 1811 | 1812 | func (x *GETSETRes) ProtoReflect() protoreflect.Message { 1813 | mi := &file_protos_res_proto_msgTypes[23] 1814 | if x != nil { 1815 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1816 | if ms.LoadMessageInfo() == nil { 1817 | ms.StoreMessageInfo(mi) 1818 | } 1819 | return ms 1820 | } 1821 | return mi.MessageOf(x) 1822 | } 1823 | 1824 | // Deprecated: Use GETSETRes.ProtoReflect.Descriptor instead. 1825 | func (*GETSETRes) Descriptor() ([]byte, []int) { 1826 | return file_protos_res_proto_rawDescGZIP(), []int{23} 1827 | } 1828 | 1829 | func (x *GETSETRes) GetValue() string { 1830 | if x != nil { 1831 | return x.Value 1832 | } 1833 | return "" 1834 | } 1835 | 1836 | type GETDELRes struct { 1837 | state protoimpl.MessageState `protogen:"open.v1"` 1838 | Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"` 1839 | unknownFields protoimpl.UnknownFields 1840 | sizeCache protoimpl.SizeCache 1841 | } 1842 | 1843 | func (x *GETDELRes) Reset() { 1844 | *x = GETDELRes{} 1845 | mi := &file_protos_res_proto_msgTypes[24] 1846 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1847 | ms.StoreMessageInfo(mi) 1848 | } 1849 | 1850 | func (x *GETDELRes) String() string { 1851 | return protoimpl.X.MessageStringOf(x) 1852 | } 1853 | 1854 | func (*GETDELRes) ProtoMessage() {} 1855 | 1856 | func (x *GETDELRes) ProtoReflect() protoreflect.Message { 1857 | mi := &file_protos_res_proto_msgTypes[24] 1858 | if x != nil { 1859 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1860 | if ms.LoadMessageInfo() == nil { 1861 | ms.StoreMessageInfo(mi) 1862 | } 1863 | return ms 1864 | } 1865 | return mi.MessageOf(x) 1866 | } 1867 | 1868 | // Deprecated: Use GETDELRes.ProtoReflect.Descriptor instead. 1869 | func (*GETDELRes) Descriptor() ([]byte, []int) { 1870 | return file_protos_res_proto_rawDescGZIP(), []int{24} 1871 | } 1872 | 1873 | func (x *GETDELRes) GetValue() string { 1874 | if x != nil { 1875 | return x.Value 1876 | } 1877 | return "" 1878 | } 1879 | 1880 | type SETRes struct { 1881 | state protoimpl.MessageState `protogen:"open.v1"` 1882 | unknownFields protoimpl.UnknownFields 1883 | sizeCache protoimpl.SizeCache 1884 | } 1885 | 1886 | func (x *SETRes) Reset() { 1887 | *x = SETRes{} 1888 | mi := &file_protos_res_proto_msgTypes[25] 1889 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1890 | ms.StoreMessageInfo(mi) 1891 | } 1892 | 1893 | func (x *SETRes) String() string { 1894 | return protoimpl.X.MessageStringOf(x) 1895 | } 1896 | 1897 | func (*SETRes) ProtoMessage() {} 1898 | 1899 | func (x *SETRes) ProtoReflect() protoreflect.Message { 1900 | mi := &file_protos_res_proto_msgTypes[25] 1901 | if x != nil { 1902 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1903 | if ms.LoadMessageInfo() == nil { 1904 | ms.StoreMessageInfo(mi) 1905 | } 1906 | return ms 1907 | } 1908 | return mi.MessageOf(x) 1909 | } 1910 | 1911 | // Deprecated: Use SETRes.ProtoReflect.Descriptor instead. 1912 | func (*SETRes) Descriptor() ([]byte, []int) { 1913 | return file_protos_res_proto_rawDescGZIP(), []int{25} 1914 | } 1915 | 1916 | type DELRes struct { 1917 | state protoimpl.MessageState `protogen:"open.v1"` 1918 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 1919 | unknownFields protoimpl.UnknownFields 1920 | sizeCache protoimpl.SizeCache 1921 | } 1922 | 1923 | func (x *DELRes) Reset() { 1924 | *x = DELRes{} 1925 | mi := &file_protos_res_proto_msgTypes[26] 1926 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1927 | ms.StoreMessageInfo(mi) 1928 | } 1929 | 1930 | func (x *DELRes) String() string { 1931 | return protoimpl.X.MessageStringOf(x) 1932 | } 1933 | 1934 | func (*DELRes) ProtoMessage() {} 1935 | 1936 | func (x *DELRes) ProtoReflect() protoreflect.Message { 1937 | mi := &file_protos_res_proto_msgTypes[26] 1938 | if x != nil { 1939 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1940 | if ms.LoadMessageInfo() == nil { 1941 | ms.StoreMessageInfo(mi) 1942 | } 1943 | return ms 1944 | } 1945 | return mi.MessageOf(x) 1946 | } 1947 | 1948 | // Deprecated: Use DELRes.ProtoReflect.Descriptor instead. 1949 | func (*DELRes) Descriptor() ([]byte, []int) { 1950 | return file_protos_res_proto_rawDescGZIP(), []int{26} 1951 | } 1952 | 1953 | func (x *DELRes) GetCount() int64 { 1954 | if x != nil { 1955 | return x.Count 1956 | } 1957 | return 0 1958 | } 1959 | 1960 | type FLUSHDBRes struct { 1961 | state protoimpl.MessageState `protogen:"open.v1"` 1962 | unknownFields protoimpl.UnknownFields 1963 | sizeCache protoimpl.SizeCache 1964 | } 1965 | 1966 | func (x *FLUSHDBRes) Reset() { 1967 | *x = FLUSHDBRes{} 1968 | mi := &file_protos_res_proto_msgTypes[27] 1969 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1970 | ms.StoreMessageInfo(mi) 1971 | } 1972 | 1973 | func (x *FLUSHDBRes) String() string { 1974 | return protoimpl.X.MessageStringOf(x) 1975 | } 1976 | 1977 | func (*FLUSHDBRes) ProtoMessage() {} 1978 | 1979 | func (x *FLUSHDBRes) ProtoReflect() protoreflect.Message { 1980 | mi := &file_protos_res_proto_msgTypes[27] 1981 | if x != nil { 1982 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 1983 | if ms.LoadMessageInfo() == nil { 1984 | ms.StoreMessageInfo(mi) 1985 | } 1986 | return ms 1987 | } 1988 | return mi.MessageOf(x) 1989 | } 1990 | 1991 | // Deprecated: Use FLUSHDBRes.ProtoReflect.Descriptor instead. 1992 | func (*FLUSHDBRes) Descriptor() ([]byte, []int) { 1993 | return file_protos_res_proto_rawDescGZIP(), []int{27} 1994 | } 1995 | 1996 | type KEYSRes struct { 1997 | state protoimpl.MessageState `protogen:"open.v1"` 1998 | Keys []string `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"` 1999 | unknownFields protoimpl.UnknownFields 2000 | sizeCache protoimpl.SizeCache 2001 | } 2002 | 2003 | func (x *KEYSRes) Reset() { 2004 | *x = KEYSRes{} 2005 | mi := &file_protos_res_proto_msgTypes[28] 2006 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2007 | ms.StoreMessageInfo(mi) 2008 | } 2009 | 2010 | func (x *KEYSRes) String() string { 2011 | return protoimpl.X.MessageStringOf(x) 2012 | } 2013 | 2014 | func (*KEYSRes) ProtoMessage() {} 2015 | 2016 | func (x *KEYSRes) ProtoReflect() protoreflect.Message { 2017 | mi := &file_protos_res_proto_msgTypes[28] 2018 | if x != nil { 2019 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2020 | if ms.LoadMessageInfo() == nil { 2021 | ms.StoreMessageInfo(mi) 2022 | } 2023 | return ms 2024 | } 2025 | return mi.MessageOf(x) 2026 | } 2027 | 2028 | // Deprecated: Use KEYSRes.ProtoReflect.Descriptor instead. 2029 | func (*KEYSRes) Descriptor() ([]byte, []int) { 2030 | return file_protos_res_proto_rawDescGZIP(), []int{28} 2031 | } 2032 | 2033 | func (x *KEYSRes) GetKeys() []string { 2034 | if x != nil { 2035 | return x.Keys 2036 | } 2037 | return nil 2038 | } 2039 | 2040 | type INCRRes struct { 2041 | state protoimpl.MessageState `protogen:"open.v1"` 2042 | Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 2043 | unknownFields protoimpl.UnknownFields 2044 | sizeCache protoimpl.SizeCache 2045 | } 2046 | 2047 | func (x *INCRRes) Reset() { 2048 | *x = INCRRes{} 2049 | mi := &file_protos_res_proto_msgTypes[29] 2050 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2051 | ms.StoreMessageInfo(mi) 2052 | } 2053 | 2054 | func (x *INCRRes) String() string { 2055 | return protoimpl.X.MessageStringOf(x) 2056 | } 2057 | 2058 | func (*INCRRes) ProtoMessage() {} 2059 | 2060 | func (x *INCRRes) ProtoReflect() protoreflect.Message { 2061 | mi := &file_protos_res_proto_msgTypes[29] 2062 | if x != nil { 2063 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2064 | if ms.LoadMessageInfo() == nil { 2065 | ms.StoreMessageInfo(mi) 2066 | } 2067 | return ms 2068 | } 2069 | return mi.MessageOf(x) 2070 | } 2071 | 2072 | // Deprecated: Use INCRRes.ProtoReflect.Descriptor instead. 2073 | func (*INCRRes) Descriptor() ([]byte, []int) { 2074 | return file_protos_res_proto_rawDescGZIP(), []int{29} 2075 | } 2076 | 2077 | func (x *INCRRes) GetValue() int64 { 2078 | if x != nil { 2079 | return x.Value 2080 | } 2081 | return 0 2082 | } 2083 | 2084 | type DECRRes struct { 2085 | state protoimpl.MessageState `protogen:"open.v1"` 2086 | Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 2087 | unknownFields protoimpl.UnknownFields 2088 | sizeCache protoimpl.SizeCache 2089 | } 2090 | 2091 | func (x *DECRRes) Reset() { 2092 | *x = DECRRes{} 2093 | mi := &file_protos_res_proto_msgTypes[30] 2094 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2095 | ms.StoreMessageInfo(mi) 2096 | } 2097 | 2098 | func (x *DECRRes) String() string { 2099 | return protoimpl.X.MessageStringOf(x) 2100 | } 2101 | 2102 | func (*DECRRes) ProtoMessage() {} 2103 | 2104 | func (x *DECRRes) ProtoReflect() protoreflect.Message { 2105 | mi := &file_protos_res_proto_msgTypes[30] 2106 | if x != nil { 2107 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2108 | if ms.LoadMessageInfo() == nil { 2109 | ms.StoreMessageInfo(mi) 2110 | } 2111 | return ms 2112 | } 2113 | return mi.MessageOf(x) 2114 | } 2115 | 2116 | // Deprecated: Use DECRRes.ProtoReflect.Descriptor instead. 2117 | func (*DECRRes) Descriptor() ([]byte, []int) { 2118 | return file_protos_res_proto_rawDescGZIP(), []int{30} 2119 | } 2120 | 2121 | func (x *DECRRes) GetValue() int64 { 2122 | if x != nil { 2123 | return x.Value 2124 | } 2125 | return 0 2126 | } 2127 | 2128 | type INCRBYRes struct { 2129 | state protoimpl.MessageState `protogen:"open.v1"` 2130 | Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 2131 | unknownFields protoimpl.UnknownFields 2132 | sizeCache protoimpl.SizeCache 2133 | } 2134 | 2135 | func (x *INCRBYRes) Reset() { 2136 | *x = INCRBYRes{} 2137 | mi := &file_protos_res_proto_msgTypes[31] 2138 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2139 | ms.StoreMessageInfo(mi) 2140 | } 2141 | 2142 | func (x *INCRBYRes) String() string { 2143 | return protoimpl.X.MessageStringOf(x) 2144 | } 2145 | 2146 | func (*INCRBYRes) ProtoMessage() {} 2147 | 2148 | func (x *INCRBYRes) ProtoReflect() protoreflect.Message { 2149 | mi := &file_protos_res_proto_msgTypes[31] 2150 | if x != nil { 2151 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2152 | if ms.LoadMessageInfo() == nil { 2153 | ms.StoreMessageInfo(mi) 2154 | } 2155 | return ms 2156 | } 2157 | return mi.MessageOf(x) 2158 | } 2159 | 2160 | // Deprecated: Use INCRBYRes.ProtoReflect.Descriptor instead. 2161 | func (*INCRBYRes) Descriptor() ([]byte, []int) { 2162 | return file_protos_res_proto_rawDescGZIP(), []int{31} 2163 | } 2164 | 2165 | func (x *INCRBYRes) GetValue() int64 { 2166 | if x != nil { 2167 | return x.Value 2168 | } 2169 | return 0 2170 | } 2171 | 2172 | type DECRBYRes struct { 2173 | state protoimpl.MessageState `protogen:"open.v1"` 2174 | Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` 2175 | unknownFields protoimpl.UnknownFields 2176 | sizeCache protoimpl.SizeCache 2177 | } 2178 | 2179 | func (x *DECRBYRes) Reset() { 2180 | *x = DECRBYRes{} 2181 | mi := &file_protos_res_proto_msgTypes[32] 2182 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2183 | ms.StoreMessageInfo(mi) 2184 | } 2185 | 2186 | func (x *DECRBYRes) String() string { 2187 | return protoimpl.X.MessageStringOf(x) 2188 | } 2189 | 2190 | func (*DECRBYRes) ProtoMessage() {} 2191 | 2192 | func (x *DECRBYRes) ProtoReflect() protoreflect.Message { 2193 | mi := &file_protos_res_proto_msgTypes[32] 2194 | if x != nil { 2195 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2196 | if ms.LoadMessageInfo() == nil { 2197 | ms.StoreMessageInfo(mi) 2198 | } 2199 | return ms 2200 | } 2201 | return mi.MessageOf(x) 2202 | } 2203 | 2204 | // Deprecated: Use DECRBYRes.ProtoReflect.Descriptor instead. 2205 | func (*DECRBYRes) Descriptor() ([]byte, []int) { 2206 | return file_protos_res_proto_rawDescGZIP(), []int{32} 2207 | } 2208 | 2209 | func (x *DECRBYRes) GetValue() int64 { 2210 | if x != nil { 2211 | return x.Value 2212 | } 2213 | return 0 2214 | } 2215 | 2216 | type ZElement struct { 2217 | state protoimpl.MessageState `protogen:"open.v1"` 2218 | Score int64 `protobuf:"varint,1,opt,name=score,proto3" json:"score,omitempty"` 2219 | Member string `protobuf:"bytes,2,opt,name=member,proto3" json:"member,omitempty"` 2220 | Rank int64 `protobuf:"varint,3,opt,name=rank,proto3" json:"rank,omitempty"` 2221 | unknownFields protoimpl.UnknownFields 2222 | sizeCache protoimpl.SizeCache 2223 | } 2224 | 2225 | func (x *ZElement) Reset() { 2226 | *x = ZElement{} 2227 | mi := &file_protos_res_proto_msgTypes[33] 2228 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2229 | ms.StoreMessageInfo(mi) 2230 | } 2231 | 2232 | func (x *ZElement) String() string { 2233 | return protoimpl.X.MessageStringOf(x) 2234 | } 2235 | 2236 | func (*ZElement) ProtoMessage() {} 2237 | 2238 | func (x *ZElement) ProtoReflect() protoreflect.Message { 2239 | mi := &file_protos_res_proto_msgTypes[33] 2240 | if x != nil { 2241 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2242 | if ms.LoadMessageInfo() == nil { 2243 | ms.StoreMessageInfo(mi) 2244 | } 2245 | return ms 2246 | } 2247 | return mi.MessageOf(x) 2248 | } 2249 | 2250 | // Deprecated: Use ZElement.ProtoReflect.Descriptor instead. 2251 | func (*ZElement) Descriptor() ([]byte, []int) { 2252 | return file_protos_res_proto_rawDescGZIP(), []int{33} 2253 | } 2254 | 2255 | func (x *ZElement) GetScore() int64 { 2256 | if x != nil { 2257 | return x.Score 2258 | } 2259 | return 0 2260 | } 2261 | 2262 | func (x *ZElement) GetMember() string { 2263 | if x != nil { 2264 | return x.Member 2265 | } 2266 | return "" 2267 | } 2268 | 2269 | func (x *ZElement) GetRank() int64 { 2270 | if x != nil { 2271 | return x.Rank 2272 | } 2273 | return 0 2274 | } 2275 | 2276 | type ZRANGERes struct { 2277 | state protoimpl.MessageState `protogen:"open.v1"` 2278 | Elements []*ZElement `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"` 2279 | unknownFields protoimpl.UnknownFields 2280 | sizeCache protoimpl.SizeCache 2281 | } 2282 | 2283 | func (x *ZRANGERes) Reset() { 2284 | *x = ZRANGERes{} 2285 | mi := &file_protos_res_proto_msgTypes[34] 2286 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2287 | ms.StoreMessageInfo(mi) 2288 | } 2289 | 2290 | func (x *ZRANGERes) String() string { 2291 | return protoimpl.X.MessageStringOf(x) 2292 | } 2293 | 2294 | func (*ZRANGERes) ProtoMessage() {} 2295 | 2296 | func (x *ZRANGERes) ProtoReflect() protoreflect.Message { 2297 | mi := &file_protos_res_proto_msgTypes[34] 2298 | if x != nil { 2299 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2300 | if ms.LoadMessageInfo() == nil { 2301 | ms.StoreMessageInfo(mi) 2302 | } 2303 | return ms 2304 | } 2305 | return mi.MessageOf(x) 2306 | } 2307 | 2308 | // Deprecated: Use ZRANGERes.ProtoReflect.Descriptor instead. 2309 | func (*ZRANGERes) Descriptor() ([]byte, []int) { 2310 | return file_protos_res_proto_rawDescGZIP(), []int{34} 2311 | } 2312 | 2313 | func (x *ZRANGERes) GetElements() []*ZElement { 2314 | if x != nil { 2315 | return x.Elements 2316 | } 2317 | return nil 2318 | } 2319 | 2320 | type ZPOPMAXRes struct { 2321 | state protoimpl.MessageState `protogen:"open.v1"` 2322 | Elements []*ZElement `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"` 2323 | unknownFields protoimpl.UnknownFields 2324 | sizeCache protoimpl.SizeCache 2325 | } 2326 | 2327 | func (x *ZPOPMAXRes) Reset() { 2328 | *x = ZPOPMAXRes{} 2329 | mi := &file_protos_res_proto_msgTypes[35] 2330 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2331 | ms.StoreMessageInfo(mi) 2332 | } 2333 | 2334 | func (x *ZPOPMAXRes) String() string { 2335 | return protoimpl.X.MessageStringOf(x) 2336 | } 2337 | 2338 | func (*ZPOPMAXRes) ProtoMessage() {} 2339 | 2340 | func (x *ZPOPMAXRes) ProtoReflect() protoreflect.Message { 2341 | mi := &file_protos_res_proto_msgTypes[35] 2342 | if x != nil { 2343 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2344 | if ms.LoadMessageInfo() == nil { 2345 | ms.StoreMessageInfo(mi) 2346 | } 2347 | return ms 2348 | } 2349 | return mi.MessageOf(x) 2350 | } 2351 | 2352 | // Deprecated: Use ZPOPMAXRes.ProtoReflect.Descriptor instead. 2353 | func (*ZPOPMAXRes) Descriptor() ([]byte, []int) { 2354 | return file_protos_res_proto_rawDescGZIP(), []int{35} 2355 | } 2356 | 2357 | func (x *ZPOPMAXRes) GetElements() []*ZElement { 2358 | if x != nil { 2359 | return x.Elements 2360 | } 2361 | return nil 2362 | } 2363 | 2364 | type ZREMRes struct { 2365 | state protoimpl.MessageState `protogen:"open.v1"` 2366 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 2367 | unknownFields protoimpl.UnknownFields 2368 | sizeCache protoimpl.SizeCache 2369 | } 2370 | 2371 | func (x *ZREMRes) Reset() { 2372 | *x = ZREMRes{} 2373 | mi := &file_protos_res_proto_msgTypes[36] 2374 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2375 | ms.StoreMessageInfo(mi) 2376 | } 2377 | 2378 | func (x *ZREMRes) String() string { 2379 | return protoimpl.X.MessageStringOf(x) 2380 | } 2381 | 2382 | func (*ZREMRes) ProtoMessage() {} 2383 | 2384 | func (x *ZREMRes) ProtoReflect() protoreflect.Message { 2385 | mi := &file_protos_res_proto_msgTypes[36] 2386 | if x != nil { 2387 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2388 | if ms.LoadMessageInfo() == nil { 2389 | ms.StoreMessageInfo(mi) 2390 | } 2391 | return ms 2392 | } 2393 | return mi.MessageOf(x) 2394 | } 2395 | 2396 | // Deprecated: Use ZREMRes.ProtoReflect.Descriptor instead. 2397 | func (*ZREMRes) Descriptor() ([]byte, []int) { 2398 | return file_protos_res_proto_rawDescGZIP(), []int{36} 2399 | } 2400 | 2401 | func (x *ZREMRes) GetCount() int64 { 2402 | if x != nil { 2403 | return x.Count 2404 | } 2405 | return 0 2406 | } 2407 | 2408 | type ZPOPMINRes struct { 2409 | state protoimpl.MessageState `protogen:"open.v1"` 2410 | Elements []*ZElement `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"` 2411 | unknownFields protoimpl.UnknownFields 2412 | sizeCache protoimpl.SizeCache 2413 | } 2414 | 2415 | func (x *ZPOPMINRes) Reset() { 2416 | *x = ZPOPMINRes{} 2417 | mi := &file_protos_res_proto_msgTypes[37] 2418 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2419 | ms.StoreMessageInfo(mi) 2420 | } 2421 | 2422 | func (x *ZPOPMINRes) String() string { 2423 | return protoimpl.X.MessageStringOf(x) 2424 | } 2425 | 2426 | func (*ZPOPMINRes) ProtoMessage() {} 2427 | 2428 | func (x *ZPOPMINRes) ProtoReflect() protoreflect.Message { 2429 | mi := &file_protos_res_proto_msgTypes[37] 2430 | if x != nil { 2431 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2432 | if ms.LoadMessageInfo() == nil { 2433 | ms.StoreMessageInfo(mi) 2434 | } 2435 | return ms 2436 | } 2437 | return mi.MessageOf(x) 2438 | } 2439 | 2440 | // Deprecated: Use ZPOPMINRes.ProtoReflect.Descriptor instead. 2441 | func (*ZPOPMINRes) Descriptor() ([]byte, []int) { 2442 | return file_protos_res_proto_rawDescGZIP(), []int{37} 2443 | } 2444 | 2445 | func (x *ZPOPMINRes) GetElements() []*ZElement { 2446 | if x != nil { 2447 | return x.Elements 2448 | } 2449 | return nil 2450 | } 2451 | 2452 | type ZRANKRes struct { 2453 | state protoimpl.MessageState `protogen:"open.v1"` 2454 | Element *ZElement `protobuf:"bytes,2,opt,name=element,proto3" json:"element,omitempty"` 2455 | unknownFields protoimpl.UnknownFields 2456 | sizeCache protoimpl.SizeCache 2457 | } 2458 | 2459 | func (x *ZRANKRes) Reset() { 2460 | *x = ZRANKRes{} 2461 | mi := &file_protos_res_proto_msgTypes[38] 2462 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2463 | ms.StoreMessageInfo(mi) 2464 | } 2465 | 2466 | func (x *ZRANKRes) String() string { 2467 | return protoimpl.X.MessageStringOf(x) 2468 | } 2469 | 2470 | func (*ZRANKRes) ProtoMessage() {} 2471 | 2472 | func (x *ZRANKRes) ProtoReflect() protoreflect.Message { 2473 | mi := &file_protos_res_proto_msgTypes[38] 2474 | if x != nil { 2475 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2476 | if ms.LoadMessageInfo() == nil { 2477 | ms.StoreMessageInfo(mi) 2478 | } 2479 | return ms 2480 | } 2481 | return mi.MessageOf(x) 2482 | } 2483 | 2484 | // Deprecated: Use ZRANKRes.ProtoReflect.Descriptor instead. 2485 | func (*ZRANKRes) Descriptor() ([]byte, []int) { 2486 | return file_protos_res_proto_rawDescGZIP(), []int{38} 2487 | } 2488 | 2489 | func (x *ZRANKRes) GetElement() *ZElement { 2490 | if x != nil { 2491 | return x.Element 2492 | } 2493 | return nil 2494 | } 2495 | 2496 | type ZCARDRes struct { 2497 | state protoimpl.MessageState `protogen:"open.v1"` 2498 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 2499 | unknownFields protoimpl.UnknownFields 2500 | sizeCache protoimpl.SizeCache 2501 | } 2502 | 2503 | func (x *ZCARDRes) Reset() { 2504 | *x = ZCARDRes{} 2505 | mi := &file_protos_res_proto_msgTypes[39] 2506 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2507 | ms.StoreMessageInfo(mi) 2508 | } 2509 | 2510 | func (x *ZCARDRes) String() string { 2511 | return protoimpl.X.MessageStringOf(x) 2512 | } 2513 | 2514 | func (*ZCARDRes) ProtoMessage() {} 2515 | 2516 | func (x *ZCARDRes) ProtoReflect() protoreflect.Message { 2517 | mi := &file_protos_res_proto_msgTypes[39] 2518 | if x != nil { 2519 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2520 | if ms.LoadMessageInfo() == nil { 2521 | ms.StoreMessageInfo(mi) 2522 | } 2523 | return ms 2524 | } 2525 | return mi.MessageOf(x) 2526 | } 2527 | 2528 | // Deprecated: Use ZCARDRes.ProtoReflect.Descriptor instead. 2529 | func (*ZCARDRes) Descriptor() ([]byte, []int) { 2530 | return file_protos_res_proto_rawDescGZIP(), []int{39} 2531 | } 2532 | 2533 | func (x *ZCARDRes) GetCount() int64 { 2534 | if x != nil { 2535 | return x.Count 2536 | } 2537 | return 0 2538 | } 2539 | 2540 | type ZRANGEWATCHRes struct { 2541 | state protoimpl.MessageState `protogen:"open.v1"` 2542 | unknownFields protoimpl.UnknownFields 2543 | sizeCache protoimpl.SizeCache 2544 | } 2545 | 2546 | func (x *ZRANGEWATCHRes) Reset() { 2547 | *x = ZRANGEWATCHRes{} 2548 | mi := &file_protos_res_proto_msgTypes[40] 2549 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2550 | ms.StoreMessageInfo(mi) 2551 | } 2552 | 2553 | func (x *ZRANGEWATCHRes) String() string { 2554 | return protoimpl.X.MessageStringOf(x) 2555 | } 2556 | 2557 | func (*ZRANGEWATCHRes) ProtoMessage() {} 2558 | 2559 | func (x *ZRANGEWATCHRes) ProtoReflect() protoreflect.Message { 2560 | mi := &file_protos_res_proto_msgTypes[40] 2561 | if x != nil { 2562 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2563 | if ms.LoadMessageInfo() == nil { 2564 | ms.StoreMessageInfo(mi) 2565 | } 2566 | return ms 2567 | } 2568 | return mi.MessageOf(x) 2569 | } 2570 | 2571 | // Deprecated: Use ZRANGEWATCHRes.ProtoReflect.Descriptor instead. 2572 | func (*ZRANGEWATCHRes) Descriptor() ([]byte, []int) { 2573 | return file_protos_res_proto_rawDescGZIP(), []int{40} 2574 | } 2575 | 2576 | type ZCOUNTWATCHRes struct { 2577 | state protoimpl.MessageState `protogen:"open.v1"` 2578 | unknownFields protoimpl.UnknownFields 2579 | sizeCache protoimpl.SizeCache 2580 | } 2581 | 2582 | func (x *ZCOUNTWATCHRes) Reset() { 2583 | *x = ZCOUNTWATCHRes{} 2584 | mi := &file_protos_res_proto_msgTypes[41] 2585 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2586 | ms.StoreMessageInfo(mi) 2587 | } 2588 | 2589 | func (x *ZCOUNTWATCHRes) String() string { 2590 | return protoimpl.X.MessageStringOf(x) 2591 | } 2592 | 2593 | func (*ZCOUNTWATCHRes) ProtoMessage() {} 2594 | 2595 | func (x *ZCOUNTWATCHRes) ProtoReflect() protoreflect.Message { 2596 | mi := &file_protos_res_proto_msgTypes[41] 2597 | if x != nil { 2598 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2599 | if ms.LoadMessageInfo() == nil { 2600 | ms.StoreMessageInfo(mi) 2601 | } 2602 | return ms 2603 | } 2604 | return mi.MessageOf(x) 2605 | } 2606 | 2607 | // Deprecated: Use ZCOUNTWATCHRes.ProtoReflect.Descriptor instead. 2608 | func (*ZCOUNTWATCHRes) Descriptor() ([]byte, []int) { 2609 | return file_protos_res_proto_rawDescGZIP(), []int{41} 2610 | } 2611 | 2612 | type ZCARDWATCHRes struct { 2613 | state protoimpl.MessageState `protogen:"open.v1"` 2614 | unknownFields protoimpl.UnknownFields 2615 | sizeCache protoimpl.SizeCache 2616 | } 2617 | 2618 | func (x *ZCARDWATCHRes) Reset() { 2619 | *x = ZCARDWATCHRes{} 2620 | mi := &file_protos_res_proto_msgTypes[42] 2621 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2622 | ms.StoreMessageInfo(mi) 2623 | } 2624 | 2625 | func (x *ZCARDWATCHRes) String() string { 2626 | return protoimpl.X.MessageStringOf(x) 2627 | } 2628 | 2629 | func (*ZCARDWATCHRes) ProtoMessage() {} 2630 | 2631 | func (x *ZCARDWATCHRes) ProtoReflect() protoreflect.Message { 2632 | mi := &file_protos_res_proto_msgTypes[42] 2633 | if x != nil { 2634 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2635 | if ms.LoadMessageInfo() == nil { 2636 | ms.StoreMessageInfo(mi) 2637 | } 2638 | return ms 2639 | } 2640 | return mi.MessageOf(x) 2641 | } 2642 | 2643 | // Deprecated: Use ZCARDWATCHRes.ProtoReflect.Descriptor instead. 2644 | func (*ZCARDWATCHRes) Descriptor() ([]byte, []int) { 2645 | return file_protos_res_proto_rawDescGZIP(), []int{42} 2646 | } 2647 | 2648 | type GEOCoords struct { 2649 | state protoimpl.MessageState `protogen:"open.v1"` 2650 | Longitude float64 `protobuf:"fixed64,1,opt,name=longitude,proto3" json:"longitude,omitempty"` 2651 | Latitude float64 `protobuf:"fixed64,2,opt,name=latitude,proto3" json:"latitude,omitempty"` 2652 | unknownFields protoimpl.UnknownFields 2653 | sizeCache protoimpl.SizeCache 2654 | } 2655 | 2656 | func (x *GEOCoords) Reset() { 2657 | *x = GEOCoords{} 2658 | mi := &file_protos_res_proto_msgTypes[43] 2659 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2660 | ms.StoreMessageInfo(mi) 2661 | } 2662 | 2663 | func (x *GEOCoords) String() string { 2664 | return protoimpl.X.MessageStringOf(x) 2665 | } 2666 | 2667 | func (*GEOCoords) ProtoMessage() {} 2668 | 2669 | func (x *GEOCoords) ProtoReflect() protoreflect.Message { 2670 | mi := &file_protos_res_proto_msgTypes[43] 2671 | if x != nil { 2672 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2673 | if ms.LoadMessageInfo() == nil { 2674 | ms.StoreMessageInfo(mi) 2675 | } 2676 | return ms 2677 | } 2678 | return mi.MessageOf(x) 2679 | } 2680 | 2681 | // Deprecated: Use GEOCoords.ProtoReflect.Descriptor instead. 2682 | func (*GEOCoords) Descriptor() ([]byte, []int) { 2683 | return file_protos_res_proto_rawDescGZIP(), []int{43} 2684 | } 2685 | 2686 | func (x *GEOCoords) GetLongitude() float64 { 2687 | if x != nil { 2688 | return x.Longitude 2689 | } 2690 | return 0 2691 | } 2692 | 2693 | func (x *GEOCoords) GetLatitude() float64 { 2694 | if x != nil { 2695 | return x.Latitude 2696 | } 2697 | return 0 2698 | } 2699 | 2700 | type GEOElement struct { 2701 | state protoimpl.MessageState `protogen:"open.v1"` 2702 | Member string `protobuf:"bytes,1,opt,name=member,proto3" json:"member,omitempty"` 2703 | Coords *GEOCoords `protobuf:"bytes,2,opt,name=coords,proto3" json:"coords,omitempty"` 2704 | Distance float64 `protobuf:"fixed64,3,opt,name=distance,proto3" json:"distance,omitempty"` 2705 | Hash uint64 `protobuf:"varint,4,opt,name=hash,proto3" json:"hash,omitempty"` 2706 | unknownFields protoimpl.UnknownFields 2707 | sizeCache protoimpl.SizeCache 2708 | } 2709 | 2710 | func (x *GEOElement) Reset() { 2711 | *x = GEOElement{} 2712 | mi := &file_protos_res_proto_msgTypes[44] 2713 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2714 | ms.StoreMessageInfo(mi) 2715 | } 2716 | 2717 | func (x *GEOElement) String() string { 2718 | return protoimpl.X.MessageStringOf(x) 2719 | } 2720 | 2721 | func (*GEOElement) ProtoMessage() {} 2722 | 2723 | func (x *GEOElement) ProtoReflect() protoreflect.Message { 2724 | mi := &file_protos_res_proto_msgTypes[44] 2725 | if x != nil { 2726 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2727 | if ms.LoadMessageInfo() == nil { 2728 | ms.StoreMessageInfo(mi) 2729 | } 2730 | return ms 2731 | } 2732 | return mi.MessageOf(x) 2733 | } 2734 | 2735 | // Deprecated: Use GEOElement.ProtoReflect.Descriptor instead. 2736 | func (*GEOElement) Descriptor() ([]byte, []int) { 2737 | return file_protos_res_proto_rawDescGZIP(), []int{44} 2738 | } 2739 | 2740 | func (x *GEOElement) GetMember() string { 2741 | if x != nil { 2742 | return x.Member 2743 | } 2744 | return "" 2745 | } 2746 | 2747 | func (x *GEOElement) GetCoords() *GEOCoords { 2748 | if x != nil { 2749 | return x.Coords 2750 | } 2751 | return nil 2752 | } 2753 | 2754 | func (x *GEOElement) GetDistance() float64 { 2755 | if x != nil { 2756 | return x.Distance 2757 | } 2758 | return 0 2759 | } 2760 | 2761 | func (x *GEOElement) GetHash() uint64 { 2762 | if x != nil { 2763 | return x.Hash 2764 | } 2765 | return 0 2766 | } 2767 | 2768 | type GEOADDRes struct { 2769 | state protoimpl.MessageState `protogen:"open.v1"` 2770 | Count int64 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` 2771 | unknownFields protoimpl.UnknownFields 2772 | sizeCache protoimpl.SizeCache 2773 | } 2774 | 2775 | func (x *GEOADDRes) Reset() { 2776 | *x = GEOADDRes{} 2777 | mi := &file_protos_res_proto_msgTypes[45] 2778 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2779 | ms.StoreMessageInfo(mi) 2780 | } 2781 | 2782 | func (x *GEOADDRes) String() string { 2783 | return protoimpl.X.MessageStringOf(x) 2784 | } 2785 | 2786 | func (*GEOADDRes) ProtoMessage() {} 2787 | 2788 | func (x *GEOADDRes) ProtoReflect() protoreflect.Message { 2789 | mi := &file_protos_res_proto_msgTypes[45] 2790 | if x != nil { 2791 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2792 | if ms.LoadMessageInfo() == nil { 2793 | ms.StoreMessageInfo(mi) 2794 | } 2795 | return ms 2796 | } 2797 | return mi.MessageOf(x) 2798 | } 2799 | 2800 | // Deprecated: Use GEOADDRes.ProtoReflect.Descriptor instead. 2801 | func (*GEOADDRes) Descriptor() ([]byte, []int) { 2802 | return file_protos_res_proto_rawDescGZIP(), []int{45} 2803 | } 2804 | 2805 | func (x *GEOADDRes) GetCount() int64 { 2806 | if x != nil { 2807 | return x.Count 2808 | } 2809 | return 0 2810 | } 2811 | 2812 | type GEODISTRes struct { 2813 | state protoimpl.MessageState `protogen:"open.v1"` 2814 | Distance float64 `protobuf:"fixed64,1,opt,name=distance,proto3" json:"distance,omitempty"` 2815 | unknownFields protoimpl.UnknownFields 2816 | sizeCache protoimpl.SizeCache 2817 | } 2818 | 2819 | func (x *GEODISTRes) Reset() { 2820 | *x = GEODISTRes{} 2821 | mi := &file_protos_res_proto_msgTypes[46] 2822 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2823 | ms.StoreMessageInfo(mi) 2824 | } 2825 | 2826 | func (x *GEODISTRes) String() string { 2827 | return protoimpl.X.MessageStringOf(x) 2828 | } 2829 | 2830 | func (*GEODISTRes) ProtoMessage() {} 2831 | 2832 | func (x *GEODISTRes) ProtoReflect() protoreflect.Message { 2833 | mi := &file_protos_res_proto_msgTypes[46] 2834 | if x != nil { 2835 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2836 | if ms.LoadMessageInfo() == nil { 2837 | ms.StoreMessageInfo(mi) 2838 | } 2839 | return ms 2840 | } 2841 | return mi.MessageOf(x) 2842 | } 2843 | 2844 | // Deprecated: Use GEODISTRes.ProtoReflect.Descriptor instead. 2845 | func (*GEODISTRes) Descriptor() ([]byte, []int) { 2846 | return file_protos_res_proto_rawDescGZIP(), []int{46} 2847 | } 2848 | 2849 | func (x *GEODISTRes) GetDistance() float64 { 2850 | if x != nil { 2851 | return x.Distance 2852 | } 2853 | return 0 2854 | } 2855 | 2856 | type GEOSEARCHRes struct { 2857 | state protoimpl.MessageState `protogen:"open.v1"` 2858 | Elements []*GEOElement `protobuf:"bytes,1,rep,name=elements,proto3" json:"elements,omitempty"` 2859 | unknownFields protoimpl.UnknownFields 2860 | sizeCache protoimpl.SizeCache 2861 | } 2862 | 2863 | func (x *GEOSEARCHRes) Reset() { 2864 | *x = GEOSEARCHRes{} 2865 | mi := &file_protos_res_proto_msgTypes[47] 2866 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2867 | ms.StoreMessageInfo(mi) 2868 | } 2869 | 2870 | func (x *GEOSEARCHRes) String() string { 2871 | return protoimpl.X.MessageStringOf(x) 2872 | } 2873 | 2874 | func (*GEOSEARCHRes) ProtoMessage() {} 2875 | 2876 | func (x *GEOSEARCHRes) ProtoReflect() protoreflect.Message { 2877 | mi := &file_protos_res_proto_msgTypes[47] 2878 | if x != nil { 2879 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2880 | if ms.LoadMessageInfo() == nil { 2881 | ms.StoreMessageInfo(mi) 2882 | } 2883 | return ms 2884 | } 2885 | return mi.MessageOf(x) 2886 | } 2887 | 2888 | // Deprecated: Use GEOSEARCHRes.ProtoReflect.Descriptor instead. 2889 | func (*GEOSEARCHRes) Descriptor() ([]byte, []int) { 2890 | return file_protos_res_proto_rawDescGZIP(), []int{47} 2891 | } 2892 | 2893 | func (x *GEOSEARCHRes) GetElements() []*GEOElement { 2894 | if x != nil { 2895 | return x.Elements 2896 | } 2897 | return nil 2898 | } 2899 | 2900 | type GEOHASHRes struct { 2901 | state protoimpl.MessageState `protogen:"open.v1"` 2902 | Hashes []string `protobuf:"bytes,1,rep,name=hashes,proto3" json:"hashes,omitempty"` 2903 | unknownFields protoimpl.UnknownFields 2904 | sizeCache protoimpl.SizeCache 2905 | } 2906 | 2907 | func (x *GEOHASHRes) Reset() { 2908 | *x = GEOHASHRes{} 2909 | mi := &file_protos_res_proto_msgTypes[48] 2910 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2911 | ms.StoreMessageInfo(mi) 2912 | } 2913 | 2914 | func (x *GEOHASHRes) String() string { 2915 | return protoimpl.X.MessageStringOf(x) 2916 | } 2917 | 2918 | func (*GEOHASHRes) ProtoMessage() {} 2919 | 2920 | func (x *GEOHASHRes) ProtoReflect() protoreflect.Message { 2921 | mi := &file_protos_res_proto_msgTypes[48] 2922 | if x != nil { 2923 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2924 | if ms.LoadMessageInfo() == nil { 2925 | ms.StoreMessageInfo(mi) 2926 | } 2927 | return ms 2928 | } 2929 | return mi.MessageOf(x) 2930 | } 2931 | 2932 | // Deprecated: Use GEOHASHRes.ProtoReflect.Descriptor instead. 2933 | func (*GEOHASHRes) Descriptor() ([]byte, []int) { 2934 | return file_protos_res_proto_rawDescGZIP(), []int{48} 2935 | } 2936 | 2937 | func (x *GEOHASHRes) GetHashes() []string { 2938 | if x != nil { 2939 | return x.Hashes 2940 | } 2941 | return nil 2942 | } 2943 | 2944 | type GEOPOSRes struct { 2945 | state protoimpl.MessageState `protogen:"open.v1"` 2946 | Coords []*GEOCoords `protobuf:"bytes,1,rep,name=coords,proto3" json:"coords,omitempty"` 2947 | unknownFields protoimpl.UnknownFields 2948 | sizeCache protoimpl.SizeCache 2949 | } 2950 | 2951 | func (x *GEOPOSRes) Reset() { 2952 | *x = GEOPOSRes{} 2953 | mi := &file_protos_res_proto_msgTypes[49] 2954 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2955 | ms.StoreMessageInfo(mi) 2956 | } 2957 | 2958 | func (x *GEOPOSRes) String() string { 2959 | return protoimpl.X.MessageStringOf(x) 2960 | } 2961 | 2962 | func (*GEOPOSRes) ProtoMessage() {} 2963 | 2964 | func (x *GEOPOSRes) ProtoReflect() protoreflect.Message { 2965 | mi := &file_protos_res_proto_msgTypes[49] 2966 | if x != nil { 2967 | ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) 2968 | if ms.LoadMessageInfo() == nil { 2969 | ms.StoreMessageInfo(mi) 2970 | } 2971 | return ms 2972 | } 2973 | return mi.MessageOf(x) 2974 | } 2975 | 2976 | // Deprecated: Use GEOPOSRes.ProtoReflect.Descriptor instead. 2977 | func (*GEOPOSRes) Descriptor() ([]byte, []int) { 2978 | return file_protos_res_proto_rawDescGZIP(), []int{49} 2979 | } 2980 | 2981 | func (x *GEOPOSRes) GetCoords() []*GEOCoords { 2982 | if x != nil { 2983 | return x.Coords 2984 | } 2985 | return nil 2986 | } 2987 | 2988 | var File_protos_res_proto protoreflect.FileDescriptor 2989 | 2990 | var file_protos_res_proto_rawDesc = string([]byte{ 2991 | 0x0a, 0x10, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x73, 0x2f, 0x72, 0x65, 0x73, 0x2e, 0x70, 0x72, 0x6f, 2992 | 0x74, 0x6f, 0x12, 0x04, 0x77, 0x69, 0x72, 0x65, 0x22, 0xbe, 0x12, 0x0a, 0x06, 0x52, 0x65, 0x73, 2993 | 0x75, 0x6c, 0x74, 0x12, 0x24, 0x0a, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x18, 0x01, 0x20, 2994 | 0x01, 0x28, 0x0e, 0x32, 0x0c, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x53, 0x74, 0x61, 0x74, 0x75, 2995 | 0x73, 0x52, 0x06, 0x73, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 2996 | 0x73, 0x61, 0x67, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 2997 | 0x61, 0x67, 0x65, 0x12, 0x24, 0x0a, 0x0d, 0x66, 0x69, 0x6e, 0x67, 0x65, 0x72, 0x70, 0x72, 0x69, 2998 | 0x6e, 0x74, 0x36, 0x34, 0x18, 0x03, 0x20, 0x01, 0x28, 0x04, 0x52, 0x0d, 0x66, 0x69, 0x6e, 0x67, 2999 | 0x65, 0x72, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x36, 0x34, 0x12, 0x29, 0x0a, 0x07, 0x54, 0x59, 0x50, 3000 | 0x45, 0x52, 0x65, 0x73, 0x18, 0x0b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 3001 | 0x65, 0x2e, 0x54, 0x59, 0x50, 0x45, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x54, 0x59, 0x50, 3002 | 0x45, 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x50, 0x49, 0x4e, 0x47, 0x52, 0x65, 0x73, 0x18, 3003 | 0x0c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x50, 0x49, 0x4e, 3004 | 0x47, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x50, 0x49, 0x4e, 0x47, 0x52, 0x65, 0x73, 0x12, 3005 | 0x29, 0x0a, 0x07, 0x45, 0x43, 0x48, 0x4f, 0x52, 0x65, 0x73, 0x18, 0x0d, 0x20, 0x01, 0x28, 0x0b, 3006 | 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x45, 0x43, 0x48, 0x4f, 0x52, 0x65, 0x73, 0x48, 3007 | 0x00, 0x52, 0x07, 0x45, 0x43, 0x48, 0x4f, 0x52, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x0c, 0x48, 0x41, 3008 | 0x4e, 0x44, 0x53, 0x48, 0x41, 0x4b, 0x45, 0x52, 0x65, 0x73, 0x18, 0x0e, 0x20, 0x01, 0x28, 0x0b, 3009 | 0x32, 0x12, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x48, 0x41, 0x4e, 0x44, 0x53, 0x48, 0x41, 0x4b, 3010 | 0x45, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x48, 0x41, 0x4e, 0x44, 0x53, 0x48, 0x41, 0x4b, 3011 | 0x45, 0x52, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x09, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x52, 0x65, 3012 | 0x73, 0x18, 0x0f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x45, 3013 | 0x58, 0x49, 0x53, 0x54, 0x53, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x45, 0x58, 0x49, 0x53, 3014 | 0x54, 0x53, 0x52, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x06, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x18, 3015 | 0x10, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x54, 3016 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x06, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x26, 0x0a, 3017 | 0x06, 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x18, 0x11, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 3018 | 0x77, 0x69, 0x72, 0x65, 0x2e, 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x06, 0x53, 3019 | 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x06, 0x44, 0x45, 0x4c, 0x52, 0x65, 0x73, 0x18, 3020 | 0x12, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x44, 0x45, 0x4c, 3021 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x06, 0x44, 0x45, 0x4c, 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 3022 | 0x07, 0x4b, 0x45, 0x59, 0x53, 0x52, 0x65, 0x73, 0x18, 0x13, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 3023 | 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x4b, 0x45, 0x59, 0x53, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 3024 | 0x07, 0x4b, 0x45, 0x59, 0x53, 0x52, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x09, 0x47, 0x45, 0x54, 0x44, 3025 | 0x45, 0x4c, 0x52, 0x65, 0x73, 0x18, 0x14, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 3026 | 0x72, 0x65, 0x2e, 0x47, 0x45, 0x54, 0x44, 0x45, 0x4c, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 3027 | 0x47, 0x45, 0x54, 0x44, 0x45, 0x4c, 0x52, 0x65, 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x47, 0x45, 0x54, 3028 | 0x45, 0x58, 0x52, 0x65, 0x73, 0x18, 0x15, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 3029 | 0x72, 0x65, 0x2e, 0x47, 0x45, 0x54, 0x45, 0x58, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x47, 3030 | 0x45, 0x54, 0x45, 0x58, 0x52, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x09, 0x47, 0x45, 0x54, 0x53, 0x45, 3031 | 0x54, 0x52, 0x65, 0x73, 0x18, 0x16, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 3032 | 0x65, 0x2e, 0x47, 0x45, 0x54, 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x47, 3033 | 0x45, 0x54, 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x49, 0x4e, 0x43, 0x52, 3034 | 0x52, 0x65, 0x73, 0x18, 0x17, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 3035 | 0x2e, 0x49, 0x4e, 0x43, 0x52, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x49, 0x4e, 0x43, 0x52, 3036 | 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x44, 0x45, 0x43, 0x52, 0x52, 0x65, 0x73, 0x18, 0x18, 3037 | 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x44, 0x45, 0x43, 0x52, 3038 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x44, 0x45, 0x43, 0x52, 0x52, 0x65, 0x73, 0x12, 0x2f, 3039 | 0x0a, 0x09, 0x49, 0x4e, 0x43, 0x52, 0x42, 0x59, 0x52, 0x65, 0x73, 0x18, 0x19, 0x20, 0x01, 0x28, 3040 | 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x49, 0x4e, 0x43, 0x52, 0x42, 0x59, 0x52, 3041 | 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x49, 0x4e, 0x43, 0x52, 0x42, 0x59, 0x52, 0x65, 0x73, 0x12, 3042 | 0x2f, 0x0a, 0x09, 0x44, 0x45, 0x43, 0x52, 0x42, 0x59, 0x52, 0x65, 0x73, 0x18, 0x1a, 0x20, 0x01, 3043 | 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x44, 0x45, 0x43, 0x52, 0x42, 0x59, 3044 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x44, 0x45, 0x43, 0x52, 0x42, 0x59, 0x52, 0x65, 0x73, 3045 | 0x12, 0x32, 0x0a, 0x0a, 0x46, 0x4c, 0x55, 0x53, 0x48, 0x44, 0x42, 0x52, 0x65, 0x73, 0x18, 0x1b, 3046 | 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x46, 0x4c, 0x55, 0x53, 3047 | 0x48, 0x44, 0x42, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x46, 0x4c, 0x55, 0x53, 0x48, 0x44, 3048 | 0x42, 0x52, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x09, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x52, 0x65, 3049 | 0x73, 0x18, 0x1c, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x45, 3050 | 0x58, 0x50, 0x49, 0x52, 0x45, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x45, 0x58, 0x50, 0x49, 3051 | 0x52, 0x45, 0x52, 0x65, 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x41, 3052 | 0x54, 0x52, 0x65, 0x73, 0x18, 0x1d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x77, 0x69, 0x72, 3053 | 0x65, 0x2e, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x41, 0x54, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 3054 | 0x0b, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x41, 0x54, 0x52, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 3055 | 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x54, 0x49, 0x4d, 0x45, 0x52, 0x65, 0x73, 0x18, 0x1e, 0x20, 3056 | 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x45, 0x58, 0x50, 0x49, 0x52, 3057 | 0x45, 0x54, 0x49, 0x4d, 0x45, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x45, 0x58, 0x50, 0x49, 3058 | 0x52, 0x45, 0x54, 0x49, 0x4d, 0x45, 0x52, 0x65, 0x73, 0x12, 0x26, 0x0a, 0x06, 0x54, 0x54, 0x4c, 3059 | 0x52, 0x65, 0x73, 0x18, 0x1f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x77, 0x69, 0x72, 0x65, 3060 | 0x2e, 0x54, 0x54, 0x4c, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x06, 0x54, 0x54, 0x4c, 0x52, 0x65, 3061 | 0x73, 0x12, 0x35, 0x0a, 0x0b, 0x47, 0x45, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 3062 | 0x18, 0x20, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 3063 | 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0b, 0x47, 0x45, 0x54, 3064 | 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x0a, 0x55, 0x4e, 0x57, 0x41, 3065 | 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x18, 0x21, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 3066 | 0x69, 0x72, 0x65, 0x2e, 0x55, 0x4e, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 3067 | 0x52, 0x0a, 0x55, 0x4e, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 3068 | 0x48, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x18, 0x22, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 3069 | 0x77, 0x69, 0x72, 0x65, 0x2e, 0x48, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 3070 | 0x48, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x48, 0x53, 0x45, 0x54, 0x52, 3071 | 0x65, 0x73, 0x18, 0x23, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 3072 | 0x48, 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x48, 0x53, 0x45, 0x54, 0x52, 3073 | 0x65, 0x73, 0x12, 0x32, 0x0a, 0x0a, 0x48, 0x47, 0x45, 0x54, 0x41, 0x4c, 0x4c, 0x52, 0x65, 0x73, 3074 | 0x18, 0x24, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x48, 0x47, 3075 | 0x45, 0x54, 0x41, 0x4c, 0x4c, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x48, 0x47, 0x45, 0x54, 3076 | 0x41, 0x4c, 0x4c, 0x52, 0x65, 0x73, 0x12, 0x38, 0x0a, 0x0c, 0x48, 0x47, 0x45, 0x54, 0x57, 0x41, 3077 | 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x18, 0x25, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x77, 3078 | 0x69, 0x72, 0x65, 0x2e, 0x48, 0x47, 0x45, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 3079 | 0x48, 0x00, 0x52, 0x0c, 0x48, 0x47, 0x45, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 3080 | 0x12, 0x41, 0x0a, 0x0f, 0x48, 0x47, 0x45, 0x54, 0x41, 0x4c, 0x4c, 0x57, 0x41, 0x54, 0x43, 0x48, 3081 | 0x52, 0x65, 0x73, 0x18, 0x26, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x77, 0x69, 0x72, 0x65, 3082 | 0x2e, 0x48, 0x47, 0x45, 0x54, 0x41, 0x4c, 0x4c, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 3083 | 0x48, 0x00, 0x52, 0x0f, 0x48, 0x47, 0x45, 0x54, 0x41, 0x4c, 0x4c, 0x57, 0x41, 0x54, 0x43, 0x48, 3084 | 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x5a, 0x41, 0x44, 0x44, 0x52, 0x65, 0x73, 0x18, 0x27, 3085 | 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x41, 0x44, 0x44, 3086 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x5a, 0x41, 0x44, 0x44, 0x52, 0x65, 0x73, 0x12, 0x2f, 3087 | 0x0a, 0x09, 0x5a, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x52, 0x65, 0x73, 0x18, 0x28, 0x20, 0x01, 0x28, 3088 | 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x52, 3089 | 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x5a, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x52, 0x65, 0x73, 0x12, 3090 | 0x2f, 0x0a, 0x09, 0x5a, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x52, 0x65, 0x73, 0x18, 0x29, 0x20, 0x01, 3091 | 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x52, 0x41, 0x4e, 0x47, 0x45, 3092 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x09, 0x5a, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x52, 0x65, 0x73, 3093 | 0x12, 0x32, 0x0a, 0x0a, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 0x41, 0x58, 0x52, 0x65, 0x73, 0x18, 0x2a, 3094 | 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x50, 0x4f, 0x50, 3095 | 0x4d, 0x41, 0x58, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 0x41, 3096 | 0x58, 0x52, 0x65, 0x73, 0x12, 0x29, 0x0a, 0x07, 0x5a, 0x52, 0x45, 0x4d, 0x52, 0x65, 0x73, 0x18, 3097 | 0x2b, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x52, 0x45, 3098 | 0x4d, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x07, 0x5a, 0x52, 0x45, 0x4d, 0x52, 0x65, 0x73, 0x12, 3099 | 0x32, 0x0a, 0x0a, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 0x49, 0x4e, 0x52, 0x65, 0x73, 0x18, 0x2c, 0x20, 3100 | 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 3101 | 0x49, 0x4e, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0a, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 0x49, 0x4e, 3102 | 0x52, 0x65, 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x5a, 0x52, 0x41, 0x4e, 0x4b, 0x52, 0x65, 0x73, 0x18, 3103 | 0x2d, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x52, 0x41, 3104 | 0x4e, 0x4b, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x5a, 0x52, 0x41, 0x4e, 0x4b, 0x52, 0x65, 3105 | 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x5a, 0x43, 0x41, 0x52, 0x44, 0x52, 0x65, 0x73, 0x18, 0x2e, 0x20, 3106 | 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x43, 0x41, 0x52, 0x44, 3107 | 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x08, 0x5a, 0x43, 0x41, 0x52, 0x44, 0x52, 0x65, 0x73, 0x12, 3108 | 0x3e, 0x0a, 0x0e, 0x5a, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 3109 | 0x73, 0x18, 0x2f, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 3110 | 0x52, 0x41, 0x4e, 0x47, 0x45, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 3111 | 0x0e, 0x5a, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 3112 | 0x3e, 0x0a, 0x0e, 0x5a, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 3113 | 0x73, 0x18, 0x30, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x14, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 3114 | 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 3115 | 0x0e, 0x5a, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 3116 | 0x3b, 0x0a, 0x0d, 0x5a, 0x43, 0x41, 0x52, 0x44, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 3117 | 0x18, 0x31, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x43, 3118 | 0x41, 0x52, 0x44, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x5a, 3119 | 0x43, 0x41, 0x52, 0x44, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 0x3b, 0x0a, 0x0d, 3120 | 0x5a, 0x52, 0x41, 0x4e, 0x4b, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x18, 0x32, 0x20, 3121 | 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x52, 0x41, 0x4e, 0x4b, 3122 | 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0d, 0x5a, 0x52, 0x41, 0x4e, 3123 | 0x4b, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x09, 0x47, 0x45, 0x4f, 3124 | 0x41, 0x44, 0x44, 0x52, 0x65, 0x73, 0x18, 0x33, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 3125 | 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x4f, 0x41, 0x44, 0x44, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 3126 | 0x09, 0x47, 0x45, 0x4f, 0x41, 0x44, 0x44, 0x52, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x0a, 0x47, 0x45, 3127 | 0x4f, 0x44, 0x49, 0x53, 0x54, 0x52, 0x65, 0x73, 0x18, 0x34, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 3128 | 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x4f, 0x44, 0x49, 0x53, 0x54, 0x52, 0x65, 0x73, 3129 | 0x48, 0x00, 0x52, 0x0a, 0x47, 0x45, 0x4f, 0x44, 0x49, 0x53, 0x54, 0x52, 0x65, 0x73, 0x12, 0x38, 3130 | 0x0a, 0x0c, 0x47, 0x45, 0x4f, 0x53, 0x45, 0x41, 0x52, 0x43, 0x48, 0x52, 0x65, 0x73, 0x18, 0x35, 3131 | 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x4f, 0x53, 3132 | 0x45, 0x41, 0x52, 0x43, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x47, 0x45, 0x4f, 0x53, 3133 | 0x45, 0x41, 0x52, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 0x32, 0x0a, 0x0a, 0x47, 0x45, 0x4f, 0x48, 3134 | 0x41, 0x53, 0x48, 0x52, 0x65, 0x73, 0x18, 0x36, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 3135 | 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x4f, 0x48, 0x41, 0x53, 0x48, 0x52, 0x65, 0x73, 0x48, 0x00, 3136 | 0x52, 0x0a, 0x47, 0x45, 0x4f, 0x48, 0x41, 0x53, 0x48, 0x52, 0x65, 0x73, 0x12, 0x2f, 0x0a, 0x09, 3137 | 0x47, 0x45, 0x4f, 0x50, 0x4f, 0x53, 0x52, 0x65, 0x73, 0x18, 0x37, 0x20, 0x01, 0x28, 0x0b, 0x32, 3138 | 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x4f, 0x50, 0x4f, 0x53, 0x52, 0x65, 0x73, 3139 | 0x48, 0x00, 0x52, 0x09, 0x47, 0x45, 0x4f, 0x50, 0x4f, 0x53, 0x52, 0x65, 0x73, 0x42, 0x0a, 0x0a, 3140 | 0x08, 0x72, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x0f, 0x0a, 0x0d, 0x5a, 0x52, 0x41, 3141 | 0x4e, 0x4b, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x22, 0x0e, 0x0a, 0x0c, 0x48, 0x47, 3142 | 0x45, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x22, 0x11, 0x0a, 0x0f, 0x48, 0x47, 3143 | 0x45, 0x54, 0x41, 0x4c, 0x4c, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x22, 0x0d, 0x0a, 3144 | 0x0b, 0x47, 0x45, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x22, 0x0c, 0x0a, 0x0a, 3145 | 0x55, 0x4e, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 0x73, 0x22, 0x1f, 0x0a, 0x07, 0x5a, 0x41, 3146 | 0x44, 0x44, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 3147 | 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x21, 0x0a, 0x09, 0x5a, 3148 | 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 3149 | 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x1d, 3150 | 0x0a, 0x07, 0x54, 0x59, 0x50, 0x45, 0x52, 0x65, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 3151 | 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x23, 0x0a, 3152 | 0x07, 0x50, 0x49, 0x4e, 0x47, 0x52, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 3153 | 0x61, 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 3154 | 0x67, 0x65, 0x22, 0x1f, 0x0a, 0x07, 0x48, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 3155 | 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 3156 | 0x6c, 0x75, 0x65, 0x22, 0x1f, 0x0a, 0x07, 0x48, 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x14, 3157 | 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 3158 | 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x32, 0x0a, 0x08, 0x48, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 3159 | 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 3160 | 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 3161 | 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x38, 0x0a, 0x0a, 0x48, 0x47, 0x45, 0x54, 3162 | 0x41, 0x4c, 0x4c, 0x52, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 3163 | 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 3164 | 0x48, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 3165 | 0x74, 0x73, 0x22, 0x22, 0x0a, 0x06, 0x54, 0x54, 0x4c, 0x52, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 3166 | 0x73, 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x07, 0x73, 3167 | 0x65, 0x63, 0x6f, 0x6e, 0x64, 0x73, 0x22, 0x2a, 0x0a, 0x09, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 3168 | 0x52, 0x65, 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 3169 | 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x67, 3170 | 0x65, 0x64, 0x22, 0x2c, 0x0a, 0x0b, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x41, 0x54, 0x52, 0x65, 3171 | 0x73, 0x12, 0x1d, 0x0a, 0x0a, 0x69, 0x73, 0x5f, 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x18, 3172 | 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x09, 0x69, 0x73, 0x43, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 3173 | 0x22, 0x2a, 0x0a, 0x0d, 0x45, 0x58, 0x50, 0x49, 0x52, 0x45, 0x54, 0x49, 0x4d, 0x45, 0x52, 0x65, 3174 | 0x73, 0x12, 0x19, 0x0a, 0x08, 0x75, 0x6e, 0x69, 0x78, 0x5f, 0x73, 0x65, 0x63, 0x18, 0x01, 0x20, 3175 | 0x01, 0x28, 0x03, 0x52, 0x07, 0x75, 0x6e, 0x69, 0x78, 0x53, 0x65, 0x63, 0x22, 0x23, 0x0a, 0x07, 3176 | 0x45, 0x43, 0x48, 0x4f, 0x52, 0x65, 0x73, 0x12, 0x18, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 3177 | 0x67, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 3178 | 0x65, 0x22, 0x21, 0x0a, 0x09, 0x45, 0x58, 0x49, 0x53, 0x54, 0x53, 0x52, 0x65, 0x73, 0x12, 0x14, 3179 | 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 3180 | 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x0e, 0x0a, 0x0c, 0x48, 0x41, 0x4e, 0x44, 0x53, 0x48, 0x41, 0x4b, 3181 | 0x45, 0x52, 0x65, 0x73, 0x22, 0x1e, 0x0a, 0x06, 0x47, 0x45, 0x54, 0x52, 0x65, 0x73, 0x12, 0x14, 3182 | 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 3183 | 0x61, 0x6c, 0x75, 0x65, 0x22, 0x20, 0x0a, 0x08, 0x47, 0x45, 0x54, 0x45, 0x58, 0x52, 0x65, 0x73, 3184 | 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 3185 | 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x09, 0x47, 0x45, 0x54, 0x53, 0x45, 0x54, 3186 | 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 3187 | 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x09, 0x47, 0x45, 0x54, 3188 | 0x44, 0x45, 0x4c, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 3189 | 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x08, 0x0a, 0x06, 3190 | 0x53, 0x45, 0x54, 0x52, 0x65, 0x73, 0x22, 0x1e, 0x0a, 0x06, 0x44, 0x45, 0x4c, 0x52, 0x65, 0x73, 3191 | 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 3192 | 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x0c, 0x0a, 0x0a, 0x46, 0x4c, 0x55, 0x53, 0x48, 0x44, 3193 | 0x42, 0x52, 0x65, 0x73, 0x22, 0x1d, 0x0a, 0x07, 0x4b, 0x45, 0x59, 0x53, 0x52, 0x65, 0x73, 0x12, 3194 | 0x12, 0x0a, 0x04, 0x6b, 0x65, 0x79, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x09, 0x52, 0x04, 0x6b, 3195 | 0x65, 0x79, 0x73, 0x22, 0x1f, 0x0a, 0x07, 0x49, 0x4e, 0x43, 0x52, 0x52, 0x65, 0x73, 0x12, 0x14, 3196 | 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 3197 | 0x61, 0x6c, 0x75, 0x65, 0x22, 0x1f, 0x0a, 0x07, 0x44, 0x45, 0x43, 0x52, 0x52, 0x65, 0x73, 0x12, 3198 | 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 3199 | 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x09, 0x49, 0x4e, 0x43, 0x52, 0x42, 0x59, 0x52, 3200 | 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 3201 | 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x21, 0x0a, 0x09, 0x44, 0x45, 0x43, 0x52, 3202 | 0x42, 0x59, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x01, 3203 | 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x4c, 0x0a, 0x08, 0x5a, 3204 | 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65, 3205 | 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x73, 0x63, 0x6f, 0x72, 0x65, 0x12, 0x16, 0x0a, 3206 | 0x06, 0x6d, 0x65, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 3207 | 0x65, 0x6d, 0x62, 0x65, 0x72, 0x12, 0x12, 0x0a, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x18, 0x03, 0x20, 3208 | 0x01, 0x28, 0x03, 0x52, 0x04, 0x72, 0x61, 0x6e, 0x6b, 0x22, 0x37, 0x0a, 0x09, 0x5a, 0x52, 0x41, 3209 | 0x4e, 0x47, 0x45, 0x52, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 3210 | 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 3211 | 0x5a, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 3212 | 0x74, 0x73, 0x22, 0x38, 0x0a, 0x0a, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 0x41, 0x58, 0x52, 0x65, 0x73, 3213 | 0x12, 0x2a, 0x0a, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 3214 | 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x45, 0x6c, 0x65, 0x6d, 0x65, 3215 | 0x6e, 0x74, 0x52, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x1f, 0x0a, 0x07, 3216 | 0x5a, 0x52, 0x45, 0x4d, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 3217 | 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x38, 0x0a, 3218 | 0x0a, 0x5a, 0x50, 0x4f, 0x50, 0x4d, 0x49, 0x4e, 0x52, 0x65, 0x73, 0x12, 0x2a, 0x0a, 0x08, 0x65, 3219 | 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 3220 | 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x65, 3221 | 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x34, 0x0a, 0x08, 0x5a, 0x52, 0x41, 0x4e, 0x4b, 3222 | 0x52, 0x65, 0x73, 0x12, 0x28, 0x0a, 0x07, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x18, 0x02, 3223 | 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x5a, 0x45, 0x6c, 0x65, 3224 | 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x07, 0x65, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x22, 0x20, 0x0a, 3225 | 0x08, 0x5a, 0x43, 0x41, 0x52, 0x44, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 3226 | 0x6e, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 3227 | 0x10, 0x0a, 0x0e, 0x5a, 0x52, 0x41, 0x4e, 0x47, 0x45, 0x57, 0x41, 0x54, 0x43, 0x48, 0x52, 0x65, 3228 | 0x73, 0x22, 0x10, 0x0a, 0x0e, 0x5a, 0x43, 0x4f, 0x55, 0x4e, 0x54, 0x57, 0x41, 0x54, 0x43, 0x48, 3229 | 0x52, 0x65, 0x73, 0x22, 0x0f, 0x0a, 0x0d, 0x5a, 0x43, 0x41, 0x52, 0x44, 0x57, 0x41, 0x54, 0x43, 3230 | 0x48, 0x52, 0x65, 0x73, 0x22, 0x45, 0x0a, 0x09, 0x47, 0x45, 0x4f, 0x43, 0x6f, 0x6f, 0x72, 0x64, 3231 | 0x73, 0x12, 0x1c, 0x0a, 0x09, 0x6c, 0x6f, 0x6e, 0x67, 0x69, 0x74, 0x75, 0x64, 0x65, 0x18, 0x01, 3232 | 0x20, 0x01, 0x28, 0x01, 0x52, 0x09, 0x6c, 0x6f, 0x6e, 0x67, 0x69, 0x74, 0x75, 0x64, 0x65, 0x12, 3233 | 0x1a, 0x0a, 0x08, 0x6c, 0x61, 0x74, 0x69, 0x74, 0x75, 0x64, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 3234 | 0x01, 0x52, 0x08, 0x6c, 0x61, 0x74, 0x69, 0x74, 0x75, 0x64, 0x65, 0x22, 0x7d, 0x0a, 0x0a, 0x47, 3235 | 0x45, 0x4f, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x12, 0x16, 0x0a, 0x06, 0x6d, 0x65, 0x6d, 3236 | 0x62, 0x65, 0x72, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x06, 0x6d, 0x65, 0x6d, 0x62, 0x65, 3237 | 0x72, 0x12, 0x27, 0x0a, 0x06, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x73, 0x18, 0x02, 0x20, 0x01, 0x28, 3238 | 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 0x47, 0x45, 0x4f, 0x43, 0x6f, 0x6f, 0x72, 3239 | 0x64, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6f, 0x72, 0x64, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x64, 0x69, 3240 | 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x64, 0x69, 3241 | 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x04, 3242 | 0x20, 0x01, 0x28, 0x04, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x22, 0x21, 0x0a, 0x09, 0x47, 0x45, 3243 | 0x4f, 0x41, 0x44, 0x44, 0x52, 0x65, 0x73, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 3244 | 0x18, 0x01, 0x20, 0x01, 0x28, 0x03, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x22, 0x28, 0x0a, 3245 | 0x0a, 0x47, 0x45, 0x4f, 0x44, 0x49, 0x53, 0x54, 0x52, 0x65, 0x73, 0x12, 0x1a, 0x0a, 0x08, 0x64, 3246 | 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x01, 0x52, 0x08, 0x64, 3247 | 0x69, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x22, 0x3c, 0x0a, 0x0c, 0x47, 0x45, 0x4f, 0x53, 0x45, 3248 | 0x41, 0x52, 0x43, 0x48, 0x52, 0x65, 0x73, 0x12, 0x2c, 0x0a, 0x08, 0x65, 0x6c, 0x65, 0x6d, 0x65, 3249 | 0x6e, 0x74, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x10, 0x2e, 0x77, 0x69, 0x72, 0x65, 3250 | 0x2e, 0x47, 0x45, 0x4f, 0x45, 0x6c, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x52, 0x08, 0x65, 0x6c, 0x65, 3251 | 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x22, 0x24, 0x0a, 0x0a, 0x47, 0x45, 0x4f, 0x48, 0x41, 0x53, 0x48, 3252 | 0x52, 0x65, 0x73, 0x12, 0x16, 0x0a, 0x06, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x18, 0x01, 0x20, 3253 | 0x03, 0x28, 0x09, 0x52, 0x06, 0x68, 0x61, 0x73, 0x68, 0x65, 0x73, 0x22, 0x34, 0x0a, 0x09, 0x47, 3254 | 0x45, 0x4f, 0x50, 0x4f, 0x53, 0x52, 0x65, 0x73, 0x12, 0x27, 0x0a, 0x06, 0x63, 0x6f, 0x6f, 0x72, 3255 | 0x64, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x77, 0x69, 0x72, 0x65, 0x2e, 3256 | 0x47, 0x45, 0x4f, 0x43, 0x6f, 0x6f, 0x72, 0x64, 0x73, 0x52, 0x06, 0x63, 0x6f, 0x6f, 0x72, 0x64, 3257 | 0x73, 0x2a, 0x19, 0x0a, 0x06, 0x53, 0x74, 0x61, 0x74, 0x75, 0x73, 0x12, 0x06, 0x0a, 0x02, 0x4f, 3258 | 0x4b, 0x10, 0x00, 0x12, 0x07, 0x0a, 0x03, 0x45, 0x52, 0x52, 0x10, 0x01, 0x42, 0x08, 0x5a, 0x06, 3259 | 0x2e, 0x2f, 0x77, 0x69, 0x72, 0x65, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, 3260 | }) 3261 | 3262 | var ( 3263 | file_protos_res_proto_rawDescOnce sync.Once 3264 | file_protos_res_proto_rawDescData []byte 3265 | ) 3266 | 3267 | func file_protos_res_proto_rawDescGZIP() []byte { 3268 | file_protos_res_proto_rawDescOnce.Do(func() { 3269 | file_protos_res_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_protos_res_proto_rawDesc), len(file_protos_res_proto_rawDesc))) 3270 | }) 3271 | return file_protos_res_proto_rawDescData 3272 | } 3273 | 3274 | var file_protos_res_proto_enumTypes = make([]protoimpl.EnumInfo, 1) 3275 | var file_protos_res_proto_msgTypes = make([]protoimpl.MessageInfo, 50) 3276 | var file_protos_res_proto_goTypes = []any{ 3277 | (Status)(0), // 0: wire.Status 3278 | (*Result)(nil), // 1: wire.Result 3279 | (*ZRANKWATCHRes)(nil), // 2: wire.ZRANKWATCHRes 3280 | (*HGETWATCHRes)(nil), // 3: wire.HGETWATCHRes 3281 | (*HGETALLWATCHRes)(nil), // 4: wire.HGETALLWATCHRes 3282 | (*GETWATCHRes)(nil), // 5: wire.GETWATCHRes 3283 | (*UNWATCHRes)(nil), // 6: wire.UNWATCHRes 3284 | (*ZADDRes)(nil), // 7: wire.ZADDRes 3285 | (*ZCOUNTRes)(nil), // 8: wire.ZCOUNTRes 3286 | (*TYPERes)(nil), // 9: wire.TYPERes 3287 | (*PINGRes)(nil), // 10: wire.PINGRes 3288 | (*HGETRes)(nil), // 11: wire.HGETRes 3289 | (*HSETRes)(nil), // 12: wire.HSETRes 3290 | (*HElement)(nil), // 13: wire.HElement 3291 | (*HGETALLRes)(nil), // 14: wire.HGETALLRes 3292 | (*TTLRes)(nil), // 15: wire.TTLRes 3293 | (*EXPIRERes)(nil), // 16: wire.EXPIRERes 3294 | (*EXPIREATRes)(nil), // 17: wire.EXPIREATRes 3295 | (*EXPIRETIMERes)(nil), // 18: wire.EXPIRETIMERes 3296 | (*ECHORes)(nil), // 19: wire.ECHORes 3297 | (*EXISTSRes)(nil), // 20: wire.EXISTSRes 3298 | (*HANDSHAKERes)(nil), // 21: wire.HANDSHAKERes 3299 | (*GETRes)(nil), // 22: wire.GETRes 3300 | (*GETEXRes)(nil), // 23: wire.GETEXRes 3301 | (*GETSETRes)(nil), // 24: wire.GETSETRes 3302 | (*GETDELRes)(nil), // 25: wire.GETDELRes 3303 | (*SETRes)(nil), // 26: wire.SETRes 3304 | (*DELRes)(nil), // 27: wire.DELRes 3305 | (*FLUSHDBRes)(nil), // 28: wire.FLUSHDBRes 3306 | (*KEYSRes)(nil), // 29: wire.KEYSRes 3307 | (*INCRRes)(nil), // 30: wire.INCRRes 3308 | (*DECRRes)(nil), // 31: wire.DECRRes 3309 | (*INCRBYRes)(nil), // 32: wire.INCRBYRes 3310 | (*DECRBYRes)(nil), // 33: wire.DECRBYRes 3311 | (*ZElement)(nil), // 34: wire.ZElement 3312 | (*ZRANGERes)(nil), // 35: wire.ZRANGERes 3313 | (*ZPOPMAXRes)(nil), // 36: wire.ZPOPMAXRes 3314 | (*ZREMRes)(nil), // 37: wire.ZREMRes 3315 | (*ZPOPMINRes)(nil), // 38: wire.ZPOPMINRes 3316 | (*ZRANKRes)(nil), // 39: wire.ZRANKRes 3317 | (*ZCARDRes)(nil), // 40: wire.ZCARDRes 3318 | (*ZRANGEWATCHRes)(nil), // 41: wire.ZRANGEWATCHRes 3319 | (*ZCOUNTWATCHRes)(nil), // 42: wire.ZCOUNTWATCHRes 3320 | (*ZCARDWATCHRes)(nil), // 43: wire.ZCARDWATCHRes 3321 | (*GEOCoords)(nil), // 44: wire.GEOCoords 3322 | (*GEOElement)(nil), // 45: wire.GEOElement 3323 | (*GEOADDRes)(nil), // 46: wire.GEOADDRes 3324 | (*GEODISTRes)(nil), // 47: wire.GEODISTRes 3325 | (*GEOSEARCHRes)(nil), // 48: wire.GEOSEARCHRes 3326 | (*GEOHASHRes)(nil), // 49: wire.GEOHASHRes 3327 | (*GEOPOSRes)(nil), // 50: wire.GEOPOSRes 3328 | } 3329 | var file_protos_res_proto_depIdxs = []int32{ 3330 | 0, // 0: wire.Result.status:type_name -> wire.Status 3331 | 9, // 1: wire.Result.TYPERes:type_name -> wire.TYPERes 3332 | 10, // 2: wire.Result.PINGRes:type_name -> wire.PINGRes 3333 | 19, // 3: wire.Result.ECHORes:type_name -> wire.ECHORes 3334 | 21, // 4: wire.Result.HANDSHAKERes:type_name -> wire.HANDSHAKERes 3335 | 20, // 5: wire.Result.EXISTSRes:type_name -> wire.EXISTSRes 3336 | 22, // 6: wire.Result.GETRes:type_name -> wire.GETRes 3337 | 26, // 7: wire.Result.SETRes:type_name -> wire.SETRes 3338 | 27, // 8: wire.Result.DELRes:type_name -> wire.DELRes 3339 | 29, // 9: wire.Result.KEYSRes:type_name -> wire.KEYSRes 3340 | 25, // 10: wire.Result.GETDELRes:type_name -> wire.GETDELRes 3341 | 23, // 11: wire.Result.GETEXRes:type_name -> wire.GETEXRes 3342 | 24, // 12: wire.Result.GETSETRes:type_name -> wire.GETSETRes 3343 | 30, // 13: wire.Result.INCRRes:type_name -> wire.INCRRes 3344 | 31, // 14: wire.Result.DECRRes:type_name -> wire.DECRRes 3345 | 32, // 15: wire.Result.INCRBYRes:type_name -> wire.INCRBYRes 3346 | 33, // 16: wire.Result.DECRBYRes:type_name -> wire.DECRBYRes 3347 | 28, // 17: wire.Result.FLUSHDBRes:type_name -> wire.FLUSHDBRes 3348 | 16, // 18: wire.Result.EXPIRERes:type_name -> wire.EXPIRERes 3349 | 17, // 19: wire.Result.EXPIREATRes:type_name -> wire.EXPIREATRes 3350 | 18, // 20: wire.Result.EXPIRETIMERes:type_name -> wire.EXPIRETIMERes 3351 | 15, // 21: wire.Result.TTLRes:type_name -> wire.TTLRes 3352 | 5, // 22: wire.Result.GETWATCHRes:type_name -> wire.GETWATCHRes 3353 | 6, // 23: wire.Result.UNWATCHRes:type_name -> wire.UNWATCHRes 3354 | 11, // 24: wire.Result.HGETRes:type_name -> wire.HGETRes 3355 | 12, // 25: wire.Result.HSETRes:type_name -> wire.HSETRes 3356 | 14, // 26: wire.Result.HGETALLRes:type_name -> wire.HGETALLRes 3357 | 3, // 27: wire.Result.HGETWATCHRes:type_name -> wire.HGETWATCHRes 3358 | 4, // 28: wire.Result.HGETALLWATCHRes:type_name -> wire.HGETALLWATCHRes 3359 | 7, // 29: wire.Result.ZADDRes:type_name -> wire.ZADDRes 3360 | 8, // 30: wire.Result.ZCOUNTRes:type_name -> wire.ZCOUNTRes 3361 | 35, // 31: wire.Result.ZRANGERes:type_name -> wire.ZRANGERes 3362 | 36, // 32: wire.Result.ZPOPMAXRes:type_name -> wire.ZPOPMAXRes 3363 | 37, // 33: wire.Result.ZREMRes:type_name -> wire.ZREMRes 3364 | 38, // 34: wire.Result.ZPOPMINRes:type_name -> wire.ZPOPMINRes 3365 | 39, // 35: wire.Result.ZRANKRes:type_name -> wire.ZRANKRes 3366 | 40, // 36: wire.Result.ZCARDRes:type_name -> wire.ZCARDRes 3367 | 41, // 37: wire.Result.ZRANGEWATCHRes:type_name -> wire.ZRANGEWATCHRes 3368 | 42, // 38: wire.Result.ZCOUNTWATCHRes:type_name -> wire.ZCOUNTWATCHRes 3369 | 43, // 39: wire.Result.ZCARDWATCHRes:type_name -> wire.ZCARDWATCHRes 3370 | 2, // 40: wire.Result.ZRANKWATCHRes:type_name -> wire.ZRANKWATCHRes 3371 | 46, // 41: wire.Result.GEOADDRes:type_name -> wire.GEOADDRes 3372 | 47, // 42: wire.Result.GEODISTRes:type_name -> wire.GEODISTRes 3373 | 48, // 43: wire.Result.GEOSEARCHRes:type_name -> wire.GEOSEARCHRes 3374 | 49, // 44: wire.Result.GEOHASHRes:type_name -> wire.GEOHASHRes 3375 | 50, // 45: wire.Result.GEOPOSRes:type_name -> wire.GEOPOSRes 3376 | 13, // 46: wire.HGETALLRes.elements:type_name -> wire.HElement 3377 | 34, // 47: wire.ZRANGERes.elements:type_name -> wire.ZElement 3378 | 34, // 48: wire.ZPOPMAXRes.elements:type_name -> wire.ZElement 3379 | 34, // 49: wire.ZPOPMINRes.elements:type_name -> wire.ZElement 3380 | 34, // 50: wire.ZRANKRes.element:type_name -> wire.ZElement 3381 | 44, // 51: wire.GEOElement.coords:type_name -> wire.GEOCoords 3382 | 45, // 52: wire.GEOSEARCHRes.elements:type_name -> wire.GEOElement 3383 | 44, // 53: wire.GEOPOSRes.coords:type_name -> wire.GEOCoords 3384 | 54, // [54:54] is the sub-list for method output_type 3385 | 54, // [54:54] is the sub-list for method input_type 3386 | 54, // [54:54] is the sub-list for extension type_name 3387 | 54, // [54:54] is the sub-list for extension extendee 3388 | 0, // [0:54] is the sub-list for field type_name 3389 | } 3390 | 3391 | func init() { file_protos_res_proto_init() } 3392 | func file_protos_res_proto_init() { 3393 | if File_protos_res_proto != nil { 3394 | return 3395 | } 3396 | file_protos_res_proto_msgTypes[0].OneofWrappers = []any{ 3397 | (*Result_TYPERes)(nil), 3398 | (*Result_PINGRes)(nil), 3399 | (*Result_ECHORes)(nil), 3400 | (*Result_HANDSHAKERes)(nil), 3401 | (*Result_EXISTSRes)(nil), 3402 | (*Result_GETRes)(nil), 3403 | (*Result_SETRes)(nil), 3404 | (*Result_DELRes)(nil), 3405 | (*Result_KEYSRes)(nil), 3406 | (*Result_GETDELRes)(nil), 3407 | (*Result_GETEXRes)(nil), 3408 | (*Result_GETSETRes)(nil), 3409 | (*Result_INCRRes)(nil), 3410 | (*Result_DECRRes)(nil), 3411 | (*Result_INCRBYRes)(nil), 3412 | (*Result_DECRBYRes)(nil), 3413 | (*Result_FLUSHDBRes)(nil), 3414 | (*Result_EXPIRERes)(nil), 3415 | (*Result_EXPIREATRes)(nil), 3416 | (*Result_EXPIRETIMERes)(nil), 3417 | (*Result_TTLRes)(nil), 3418 | (*Result_GETWATCHRes)(nil), 3419 | (*Result_UNWATCHRes)(nil), 3420 | (*Result_HGETRes)(nil), 3421 | (*Result_HSETRes)(nil), 3422 | (*Result_HGETALLRes)(nil), 3423 | (*Result_HGETWATCHRes)(nil), 3424 | (*Result_HGETALLWATCHRes)(nil), 3425 | (*Result_ZADDRes)(nil), 3426 | (*Result_ZCOUNTRes)(nil), 3427 | (*Result_ZRANGERes)(nil), 3428 | (*Result_ZPOPMAXRes)(nil), 3429 | (*Result_ZREMRes)(nil), 3430 | (*Result_ZPOPMINRes)(nil), 3431 | (*Result_ZRANKRes)(nil), 3432 | (*Result_ZCARDRes)(nil), 3433 | (*Result_ZRANGEWATCHRes)(nil), 3434 | (*Result_ZCOUNTWATCHRes)(nil), 3435 | (*Result_ZCARDWATCHRes)(nil), 3436 | (*Result_ZRANKWATCHRes)(nil), 3437 | (*Result_GEOADDRes)(nil), 3438 | (*Result_GEODISTRes)(nil), 3439 | (*Result_GEOSEARCHRes)(nil), 3440 | (*Result_GEOHASHRes)(nil), 3441 | (*Result_GEOPOSRes)(nil), 3442 | } 3443 | type x struct{} 3444 | out := protoimpl.TypeBuilder{ 3445 | File: protoimpl.DescBuilder{ 3446 | GoPackagePath: reflect.TypeOf(x{}).PkgPath(), 3447 | RawDescriptor: unsafe.Slice(unsafe.StringData(file_protos_res_proto_rawDesc), len(file_protos_res_proto_rawDesc)), 3448 | NumEnums: 1, 3449 | NumMessages: 50, 3450 | NumExtensions: 0, 3451 | NumServices: 0, 3452 | }, 3453 | GoTypes: file_protos_res_proto_goTypes, 3454 | DependencyIndexes: file_protos_res_proto_depIdxs, 3455 | EnumInfos: file_protos_res_proto_enumTypes, 3456 | MessageInfos: file_protos_res_proto_msgTypes, 3457 | }.Build() 3458 | File_protos_res_proto = out.File 3459 | file_protos_res_proto_goTypes = nil 3460 | file_protos_res_proto_depIdxs = nil 3461 | } 3462 | --------------------------------------------------------------------------------