From 9d2fd47aecbfd422045ba9a9666d4d16e19eb21e Mon Sep 17 00:00:00 2001 From: qishenonly <1050026498@qq.com> Date: Fri, 21 Jul 2023 18:36:44 +0800 Subject: [PATCH] Add glist grpc --- lib/proto/glist/db.pb.go | 2870 ++++++++++++++++++++++++++++++++- lib/proto/glist/db.proto | 194 ++- lib/proto/glist/db_grpc.pb.go | 446 ++++- 3 files changed, 3477 insertions(+), 33 deletions(-) diff --git a/lib/proto/glist/db.pb.go b/lib/proto/glist/db.pb.go index ec241fb5..dd4dcfee 100644 --- a/lib/proto/glist/db.pb.go +++ b/lib/proto/glist/db.pb.go @@ -2,7 +2,7 @@ // versions: // protoc-gen-go v1.28.1 // protoc v3.6.1 -// source: lib/proto/glist/db.proto +// source: db.proto package glist @@ -10,6 +10,7 @@ import ( protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" reflect "reflect" + sync "sync" ) const ( @@ -19,46 +20,2861 @@ const ( _ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20) ) -var File_lib_proto_glist_db_proto protoreflect.FileDescriptor +type GListLPushRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields -var file_lib_proto_glist_db_proto_rawDesc = []byte{ - 0x0a, 0x18, 0x6c, 0x69, 0x62, 0x2f, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6c, 0x69, 0x73, - 0x74, 0x2f, 0x64, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x67, 0x6c, 0x69, 0x73, - 0x74, 0x32, 0x0e, 0x0a, 0x0c, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, - 0x65, 0x42, 0x17, 0x5a, 0x15, 0x66, 0x6c, 0x79, 0x64, 0x62, 0x2f, 0x6c, 0x69, 0x62, 0x2f, 0x70, - 0x72, 0x6f, 0x74, 0x6f, 0x2f, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, - 0x6f, 0x33, + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // Types that are assignable to Value: + // + // *GListLPushRequest_StringValue + // *GListLPushRequest_Int32Value + // *GListLPushRequest_Int64Value + // *GListLPushRequest_Float32Value + // *GListLPushRequest_Float64Value + // *GListLPushRequest_BoolValue + // *GListLPushRequest_BytesValue + Value isGListLPushRequest_Value `protobuf_oneof:"value"` } -var file_lib_proto_glist_db_proto_goTypes = []interface{}{} -var file_lib_proto_glist_db_proto_depIdxs = []int32{ - 0, // [0:0] is the sub-list for method output_type - 0, // [0:0] is the sub-list for method input_type - 0, // [0:0] is the sub-list for extension type_name - 0, // [0:0] is the sub-list for extension extendee - 0, // [0:0] is the sub-list for field type_name +func (x *GListLPushRequest) Reset() { + *x = GListLPushRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[0] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLPushRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLPushRequest) ProtoMessage() {} + +func (x *GListLPushRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[0] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLPushRequest.ProtoReflect.Descriptor instead. +func (*GListLPushRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{0} +} + +func (x *GListLPushRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (m *GListLPushRequest) GetValue() isGListLPushRequest_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListLPushRequest) GetStringValue() string { + if x, ok := x.GetValue().(*GListLPushRequest_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListLPushRequest) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListLPushRequest_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListLPushRequest) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListLPushRequest_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListLPushRequest) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListLPushRequest_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListLPushRequest) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListLPushRequest_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListLPushRequest) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListLPushRequest_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListLPushRequest) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListLPushRequest_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListLPushRequest_Value interface { + isGListLPushRequest_Value() +} + +type GListLPushRequest_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListLPushRequest_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListLPushRequest_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListLPushRequest_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListLPushRequest_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListLPushRequest_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListLPushRequest_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListLPushRequest_StringValue) isGListLPushRequest_Value() {} + +func (*GListLPushRequest_Int32Value) isGListLPushRequest_Value() {} + +func (*GListLPushRequest_Int64Value) isGListLPushRequest_Value() {} + +func (*GListLPushRequest_Float32Value) isGListLPushRequest_Value() {} + +func (*GListLPushRequest_Float64Value) isGListLPushRequest_Value() {} + +func (*GListLPushRequest_BoolValue) isGListLPushRequest_Value() {} + +func (*GListLPushRequest_BytesValue) isGListLPushRequest_Value() {} + +type GListLPushResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListLPushResponse) Reset() { + *x = GListLPushResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[1] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLPushResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLPushResponse) ProtoMessage() {} + +func (x *GListLPushResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[1] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLPushResponse.ProtoReflect.Descriptor instead. +func (*GListLPushResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{1} +} + +func (x *GListLPushResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListLPushsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Values []*Value `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"` +} + +func (x *GListLPushsRequest) Reset() { + *x = GListLPushsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[2] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLPushsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLPushsRequest) ProtoMessage() {} + +func (x *GListLPushsRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[2] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLPushsRequest.ProtoReflect.Descriptor instead. +func (*GListLPushsRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{2} +} + +func (x *GListLPushsRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListLPushsRequest) GetValues() []*Value { + if x != nil { + return x.Values + } + return nil +} + +type Value struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *Value_StringValue + // *Value_Int32Value + // *Value_Int64Value + // *Value_Float32Value + // *Value_Float64Value + // *Value_BoolValue + // *Value_BytesValue + Value isValue_Value `protobuf_oneof:"value"` +} + +func (x *Value) Reset() { + *x = Value{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[3] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *Value) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*Value) ProtoMessage() {} + +func (x *Value) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[3] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use Value.ProtoReflect.Descriptor instead. +func (*Value) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{3} +} + +func (m *Value) GetValue() isValue_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *Value) GetStringValue() string { + if x, ok := x.GetValue().(*Value_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *Value) GetInt32Value() int32 { + if x, ok := x.GetValue().(*Value_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *Value) GetInt64Value() int64 { + if x, ok := x.GetValue().(*Value_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *Value) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*Value_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *Value) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*Value_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *Value) GetBoolValue() bool { + if x, ok := x.GetValue().(*Value_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *Value) GetBytesValue() []byte { + if x, ok := x.GetValue().(*Value_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isValue_Value interface { + isValue_Value() +} + +type Value_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type Value_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type Value_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type Value_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type Value_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type Value_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type Value_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*Value_StringValue) isValue_Value() {} + +func (*Value_Int32Value) isValue_Value() {} + +func (*Value_Int64Value) isValue_Value() {} + +func (*Value_Float32Value) isValue_Value() {} + +func (*Value_Float64Value) isValue_Value() {} + +func (*Value_BoolValue) isValue_Value() {} + +func (*Value_BytesValue) isValue_Value() {} + +type GListLPushsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListLPushsResponse) Reset() { + *x = GListLPushsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[4] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLPushsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLPushsResponse) ProtoMessage() {} + +func (x *GListLPushsResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[4] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLPushsResponse.ProtoReflect.Descriptor instead. +func (*GListLPushsResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{4} +} + +func (x *GListLPushsResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListRPushRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + // Types that are assignable to Value: + // + // *GListRPushRequest_StringValue + // *GListRPushRequest_Int32Value + // *GListRPushRequest_Int64Value + // *GListRPushRequest_Float32Value + // *GListRPushRequest_Float64Value + // *GListRPushRequest_BoolValue + // *GListRPushRequest_BytesValue + Value isGListRPushRequest_Value `protobuf_oneof:"value"` +} + +func (x *GListRPushRequest) Reset() { + *x = GListRPushRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListRPushRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListRPushRequest) ProtoMessage() {} + +func (x *GListRPushRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[5] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListRPushRequest.ProtoReflect.Descriptor instead. +func (*GListRPushRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{5} +} + +func (x *GListRPushRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (m *GListRPushRequest) GetValue() isGListRPushRequest_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListRPushRequest) GetStringValue() string { + if x, ok := x.GetValue().(*GListRPushRequest_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListRPushRequest) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListRPushRequest_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListRPushRequest) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListRPushRequest_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListRPushRequest) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListRPushRequest_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListRPushRequest) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListRPushRequest_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListRPushRequest) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListRPushRequest_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListRPushRequest) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListRPushRequest_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListRPushRequest_Value interface { + isGListRPushRequest_Value() +} + +type GListRPushRequest_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListRPushRequest_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListRPushRequest_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListRPushRequest_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListRPushRequest_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListRPushRequest_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListRPushRequest_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListRPushRequest_StringValue) isGListRPushRequest_Value() {} + +func (*GListRPushRequest_Int32Value) isGListRPushRequest_Value() {} + +func (*GListRPushRequest_Int64Value) isGListRPushRequest_Value() {} + +func (*GListRPushRequest_Float32Value) isGListRPushRequest_Value() {} + +func (*GListRPushRequest_Float64Value) isGListRPushRequest_Value() {} + +func (*GListRPushRequest_BoolValue) isGListRPushRequest_Value() {} + +func (*GListRPushRequest_BytesValue) isGListRPushRequest_Value() {} + +type GListRPushResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListRPushResponse) Reset() { + *x = GListRPushResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListRPushResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListRPushResponse) ProtoMessage() {} + +func (x *GListRPushResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[6] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListRPushResponse.ProtoReflect.Descriptor instead. +func (*GListRPushResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{6} +} + +func (x *GListRPushResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListRPushsRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Values []*Value `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"` +} + +func (x *GListRPushsRequest) Reset() { + *x = GListRPushsRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListRPushsRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListRPushsRequest) ProtoMessage() {} + +func (x *GListRPushsRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[7] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListRPushsRequest.ProtoReflect.Descriptor instead. +func (*GListRPushsRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{7} +} + +func (x *GListRPushsRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListRPushsRequest) GetValues() []*Value { + if x != nil { + return x.Values + } + return nil +} + +type GListRPushsResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListRPushsResponse) Reset() { + *x = GListRPushsResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListRPushsResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListRPushsResponse) ProtoMessage() {} + +func (x *GListRPushsResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[8] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListRPushsResponse.ProtoReflect.Descriptor instead. +func (*GListRPushsResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{8} +} + +func (x *GListRPushsResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListLPopRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` +} + +func (x *GListLPopRequest) Reset() { + *x = GListLPopRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLPopRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLPopRequest) ProtoMessage() {} + +func (x *GListLPopRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[9] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLPopRequest.ProtoReflect.Descriptor instead. +func (*GListLPopRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{9} +} + +func (x *GListLPopRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type GListLPopResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *GListLPopResponse_StringValue + // *GListLPopResponse_Int32Value + // *GListLPopResponse_Int64Value + // *GListLPopResponse_Float32Value + // *GListLPopResponse_Float64Value + // *GListLPopResponse_BoolValue + // *GListLPopResponse_BytesValue + Value isGListLPopResponse_Value `protobuf_oneof:"value"` +} + +func (x *GListLPopResponse) Reset() { + *x = GListLPopResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLPopResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLPopResponse) ProtoMessage() {} + +func (x *GListLPopResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[10] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLPopResponse.ProtoReflect.Descriptor instead. +func (*GListLPopResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{10} +} + +func (m *GListLPopResponse) GetValue() isGListLPopResponse_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListLPopResponse) GetStringValue() string { + if x, ok := x.GetValue().(*GListLPopResponse_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListLPopResponse) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListLPopResponse_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListLPopResponse) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListLPopResponse_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListLPopResponse) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListLPopResponse_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListLPopResponse) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListLPopResponse_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListLPopResponse) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListLPopResponse_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListLPopResponse) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListLPopResponse_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListLPopResponse_Value interface { + isGListLPopResponse_Value() +} + +type GListLPopResponse_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListLPopResponse_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListLPopResponse_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListLPopResponse_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListLPopResponse_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListLPopResponse_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListLPopResponse_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListLPopResponse_StringValue) isGListLPopResponse_Value() {} + +func (*GListLPopResponse_Int32Value) isGListLPopResponse_Value() {} + +func (*GListLPopResponse_Int64Value) isGListLPopResponse_Value() {} + +func (*GListLPopResponse_Float32Value) isGListLPopResponse_Value() {} + +func (*GListLPopResponse_Float64Value) isGListLPopResponse_Value() {} + +func (*GListLPopResponse_BoolValue) isGListLPopResponse_Value() {} + +func (*GListLPopResponse_BytesValue) isGListLPopResponse_Value() {} + +type GListRPopRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` +} + +func (x *GListRPopRequest) Reset() { + *x = GListRPopRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListRPopRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListRPopRequest) ProtoMessage() {} + +func (x *GListRPopRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[11] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListRPopRequest.ProtoReflect.Descriptor instead. +func (*GListRPopRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{11} +} + +func (x *GListRPopRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type GListRPopResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *GListRPopResponse_StringValue + // *GListRPopResponse_Int32Value + // *GListRPopResponse_Int64Value + // *GListRPopResponse_Float32Value + // *GListRPopResponse_Float64Value + // *GListRPopResponse_BoolValue + // *GListRPopResponse_BytesValue + Value isGListRPopResponse_Value `protobuf_oneof:"value"` +} + +func (x *GListRPopResponse) Reset() { + *x = GListRPopResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListRPopResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListRPopResponse) ProtoMessage() {} + +func (x *GListRPopResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[12] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListRPopResponse.ProtoReflect.Descriptor instead. +func (*GListRPopResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{12} +} + +func (m *GListRPopResponse) GetValue() isGListRPopResponse_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListRPopResponse) GetStringValue() string { + if x, ok := x.GetValue().(*GListRPopResponse_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListRPopResponse) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListRPopResponse_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListRPopResponse) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListRPopResponse_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListRPopResponse) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListRPopResponse_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListRPopResponse) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListRPopResponse_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListRPopResponse) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListRPopResponse_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListRPopResponse) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListRPopResponse_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListRPopResponse_Value interface { + isGListRPopResponse_Value() +} + +type GListRPopResponse_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListRPopResponse_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListRPopResponse_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListRPopResponse_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListRPopResponse_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListRPopResponse_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListRPopResponse_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListRPopResponse_StringValue) isGListRPopResponse_Value() {} + +func (*GListRPopResponse_Int32Value) isGListRPopResponse_Value() {} + +func (*GListRPopResponse_Int64Value) isGListRPopResponse_Value() {} + +func (*GListRPopResponse_Float32Value) isGListRPopResponse_Value() {} + +func (*GListRPopResponse_Float64Value) isGListRPopResponse_Value() {} + +func (*GListRPopResponse_BoolValue) isGListRPopResponse_Value() {} + +func (*GListRPopResponse_BytesValue) isGListRPopResponse_Value() {} + +type GListLRangeRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Start int32 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"` + Stop int32 `protobuf:"varint,3,opt,name=stop,proto3" json:"stop,omitempty"` +} + +func (x *GListLRangeRequest) Reset() { + *x = GListLRangeRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLRangeRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLRangeRequest) ProtoMessage() {} + +func (x *GListLRangeRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[13] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLRangeRequest.ProtoReflect.Descriptor instead. +func (*GListLRangeRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{13} +} + +func (x *GListLRangeRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListLRangeRequest) GetStart() int32 { + if x != nil { + return x.Start + } + return 0 +} + +func (x *GListLRangeRequest) GetStop() int32 { + if x != nil { + return x.Stop + } + return 0 +} + +type GListLRangeResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Values []*Value `protobuf:"bytes,1,rep,name=values,proto3" json:"values,omitempty"` +} + +func (x *GListLRangeResponse) Reset() { + *x = GListLRangeResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[14] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLRangeResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLRangeResponse) ProtoMessage() {} + +func (x *GListLRangeResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[14] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLRangeResponse.ProtoReflect.Descriptor instead. +func (*GListLRangeResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{14} +} + +func (x *GListLRangeResponse) GetValues() []*Value { + if x != nil { + return x.Values + } + return nil +} + +type GListLLenRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` +} + +func (x *GListLLenRequest) Reset() { + *x = GListLLenRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[15] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLLenRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLLenRequest) ProtoMessage() {} + +func (x *GListLLenRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[15] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLLenRequest.ProtoReflect.Descriptor instead. +func (*GListLLenRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{15} +} + +func (x *GListLLenRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +type GListLLenResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Length int32 `protobuf:"varint,1,opt,name=length,proto3" json:"length,omitempty"` + Ok bool `protobuf:"varint,2,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListLLenResponse) Reset() { + *x = GListLLenResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[16] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLLenResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLLenResponse) ProtoMessage() {} + +func (x *GListLLenResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[16] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLLenResponse.ProtoReflect.Descriptor instead. +func (*GListLLenResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{16} +} + +func (x *GListLLenResponse) GetLength() int32 { + if x != nil { + return x.Length + } + return 0 +} + +func (x *GListLLenResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListLRemRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Count int32 `protobuf:"varint,2,opt,name=count,proto3" json:"count,omitempty"` + // Types that are assignable to Value: + // + // *GListLRemRequest_StringValue + // *GListLRemRequest_Int32Value + // *GListLRemRequest_Int64Value + // *GListLRemRequest_Float32Value + // *GListLRemRequest_Float64Value + // *GListLRemRequest_BoolValue + // *GListLRemRequest_BytesValue + Value isGListLRemRequest_Value `protobuf_oneof:"value"` +} + +func (x *GListLRemRequest) Reset() { + *x = GListLRemRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[17] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLRemRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLRemRequest) ProtoMessage() {} + +func (x *GListLRemRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[17] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLRemRequest.ProtoReflect.Descriptor instead. +func (*GListLRemRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{17} +} + +func (x *GListLRemRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListLRemRequest) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +func (m *GListLRemRequest) GetValue() isGListLRemRequest_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListLRemRequest) GetStringValue() string { + if x, ok := x.GetValue().(*GListLRemRequest_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListLRemRequest) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListLRemRequest_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListLRemRequest) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListLRemRequest_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListLRemRequest) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListLRemRequest_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListLRemRequest) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListLRemRequest_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListLRemRequest) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListLRemRequest_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListLRemRequest) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListLRemRequest_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListLRemRequest_Value interface { + isGListLRemRequest_Value() +} + +type GListLRemRequest_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListLRemRequest_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListLRemRequest_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListLRemRequest_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListLRemRequest_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListLRemRequest_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListLRemRequest_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListLRemRequest_StringValue) isGListLRemRequest_Value() {} + +func (*GListLRemRequest_Int32Value) isGListLRemRequest_Value() {} + +func (*GListLRemRequest_Int64Value) isGListLRemRequest_Value() {} + +func (*GListLRemRequest_Float32Value) isGListLRemRequest_Value() {} + +func (*GListLRemRequest_Float64Value) isGListLRemRequest_Value() {} + +func (*GListLRemRequest_BoolValue) isGListLRemRequest_Value() {} + +func (*GListLRemRequest_BytesValue) isGListLRemRequest_Value() {} + +type GListLRemResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Count int32 `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"` + Ok bool `protobuf:"varint,2,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListLRemResponse) Reset() { + *x = GListLRemResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[18] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLRemResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLRemResponse) ProtoMessage() {} + +func (x *GListLRemResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[18] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLRemResponse.ProtoReflect.Descriptor instead. +func (*GListLRemResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{18} +} + +func (x *GListLRemResponse) GetCount() int32 { + if x != nil { + return x.Count + } + return 0 +} + +func (x *GListLRemResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListLIndexRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Index int32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` +} + +func (x *GListLIndexRequest) Reset() { + *x = GListLIndexRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[19] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLIndexRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLIndexRequest) ProtoMessage() {} + +func (x *GListLIndexRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[19] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLIndexRequest.ProtoReflect.Descriptor instead. +func (*GListLIndexRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{19} +} + +func (x *GListLIndexRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListLIndexRequest) GetIndex() int32 { + if x != nil { + return x.Index + } + return 0 +} + +type GListLIndexResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + // Types that are assignable to Value: + // + // *GListLIndexResponse_StringValue + // *GListLIndexResponse_Int32Value + // *GListLIndexResponse_Int64Value + // *GListLIndexResponse_Float32Value + // *GListLIndexResponse_Float64Value + // *GListLIndexResponse_BoolValue + // *GListLIndexResponse_BytesValue + Value isGListLIndexResponse_Value `protobuf_oneof:"value"` +} + +func (x *GListLIndexResponse) Reset() { + *x = GListLIndexResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[20] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLIndexResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLIndexResponse) ProtoMessage() {} + +func (x *GListLIndexResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[20] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLIndexResponse.ProtoReflect.Descriptor instead. +func (*GListLIndexResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{20} +} + +func (m *GListLIndexResponse) GetValue() isGListLIndexResponse_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListLIndexResponse) GetStringValue() string { + if x, ok := x.GetValue().(*GListLIndexResponse_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListLIndexResponse) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListLIndexResponse_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListLIndexResponse) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListLIndexResponse_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListLIndexResponse) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListLIndexResponse_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListLIndexResponse) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListLIndexResponse_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListLIndexResponse) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListLIndexResponse_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListLIndexResponse) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListLIndexResponse_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListLIndexResponse_Value interface { + isGListLIndexResponse_Value() +} + +type GListLIndexResponse_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListLIndexResponse_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListLIndexResponse_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListLIndexResponse_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListLIndexResponse_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListLIndexResponse_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListLIndexResponse_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListLIndexResponse_StringValue) isGListLIndexResponse_Value() {} + +func (*GListLIndexResponse_Int32Value) isGListLIndexResponse_Value() {} + +func (*GListLIndexResponse_Int64Value) isGListLIndexResponse_Value() {} + +func (*GListLIndexResponse_Float32Value) isGListLIndexResponse_Value() {} + +func (*GListLIndexResponse_Float64Value) isGListLIndexResponse_Value() {} + +func (*GListLIndexResponse_BoolValue) isGListLIndexResponse_Value() {} + +func (*GListLIndexResponse_BytesValue) isGListLIndexResponse_Value() {} + +type GListLSetRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Index int32 `protobuf:"varint,2,opt,name=index,proto3" json:"index,omitempty"` + // Types that are assignable to Value: + // + // *GListLSetRequest_StringValue + // *GListLSetRequest_Int32Value + // *GListLSetRequest_Int64Value + // *GListLSetRequest_Float32Value + // *GListLSetRequest_Float64Value + // *GListLSetRequest_BoolValue + // *GListLSetRequest_BytesValue + Value isGListLSetRequest_Value `protobuf_oneof:"value"` +} + +func (x *GListLSetRequest) Reset() { + *x = GListLSetRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[21] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLSetRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLSetRequest) ProtoMessage() {} + +func (x *GListLSetRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[21] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLSetRequest.ProtoReflect.Descriptor instead. +func (*GListLSetRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{21} +} + +func (x *GListLSetRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListLSetRequest) GetIndex() int32 { + if x != nil { + return x.Index + } + return 0 +} + +func (m *GListLSetRequest) GetValue() isGListLSetRequest_Value { + if m != nil { + return m.Value + } + return nil +} + +func (x *GListLSetRequest) GetStringValue() string { + if x, ok := x.GetValue().(*GListLSetRequest_StringValue); ok { + return x.StringValue + } + return "" +} + +func (x *GListLSetRequest) GetInt32Value() int32 { + if x, ok := x.GetValue().(*GListLSetRequest_Int32Value); ok { + return x.Int32Value + } + return 0 +} + +func (x *GListLSetRequest) GetInt64Value() int64 { + if x, ok := x.GetValue().(*GListLSetRequest_Int64Value); ok { + return x.Int64Value + } + return 0 +} + +func (x *GListLSetRequest) GetFloat32Value() float32 { + if x, ok := x.GetValue().(*GListLSetRequest_Float32Value); ok { + return x.Float32Value + } + return 0 +} + +func (x *GListLSetRequest) GetFloat64Value() float64 { + if x, ok := x.GetValue().(*GListLSetRequest_Float64Value); ok { + return x.Float64Value + } + return 0 +} + +func (x *GListLSetRequest) GetBoolValue() bool { + if x, ok := x.GetValue().(*GListLSetRequest_BoolValue); ok { + return x.BoolValue + } + return false +} + +func (x *GListLSetRequest) GetBytesValue() []byte { + if x, ok := x.GetValue().(*GListLSetRequest_BytesValue); ok { + return x.BytesValue + } + return nil +} + +type isGListLSetRequest_Value interface { + isGListLSetRequest_Value() +} + +type GListLSetRequest_StringValue struct { + StringValue string `protobuf:"bytes,3,opt,name=StringValue,proto3,oneof"` +} + +type GListLSetRequest_Int32Value struct { + Int32Value int32 `protobuf:"varint,4,opt,name=Int32Value,proto3,oneof"` +} + +type GListLSetRequest_Int64Value struct { + Int64Value int64 `protobuf:"varint,5,opt,name=Int64Value,proto3,oneof"` +} + +type GListLSetRequest_Float32Value struct { + Float32Value float32 `protobuf:"fixed32,6,opt,name=Float32Value,proto3,oneof"` +} + +type GListLSetRequest_Float64Value struct { + Float64Value float64 `protobuf:"fixed64,7,opt,name=Float64Value,proto3,oneof"` +} + +type GListLSetRequest_BoolValue struct { + BoolValue bool `protobuf:"varint,8,opt,name=BoolValue,proto3,oneof"` +} + +type GListLSetRequest_BytesValue struct { + BytesValue []byte `protobuf:"bytes,9,opt,name=BytesValue,proto3,oneof"` +} + +func (*GListLSetRequest_StringValue) isGListLSetRequest_Value() {} + +func (*GListLSetRequest_Int32Value) isGListLSetRequest_Value() {} + +func (*GListLSetRequest_Int64Value) isGListLSetRequest_Value() {} + +func (*GListLSetRequest_Float32Value) isGListLSetRequest_Value() {} + +func (*GListLSetRequest_Float64Value) isGListLSetRequest_Value() {} + +func (*GListLSetRequest_BoolValue) isGListLSetRequest_Value() {} + +func (*GListLSetRequest_BytesValue) isGListLSetRequest_Value() {} + +type GListLSetResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListLSetResponse) Reset() { + *x = GListLSetResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[22] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLSetResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLSetResponse) ProtoMessage() {} + +func (x *GListLSetResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[22] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) } -func init() { file_lib_proto_glist_db_proto_init() } -func file_lib_proto_glist_db_proto_init() { - if File_lib_proto_glist_db_proto != nil { +// Deprecated: Use GListLSetResponse.ProtoReflect.Descriptor instead. +func (*GListLSetResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{22} +} + +func (x *GListLSetResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +type GListLTrimRequest struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` + Start int32 `protobuf:"varint,2,opt,name=start,proto3" json:"start,omitempty"` + Stop int32 `protobuf:"varint,3,opt,name=stop,proto3" json:"stop,omitempty"` +} + +func (x *GListLTrimRequest) Reset() { + *x = GListLTrimRequest{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[23] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLTrimRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLTrimRequest) ProtoMessage() {} + +func (x *GListLTrimRequest) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[23] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLTrimRequest.ProtoReflect.Descriptor instead. +func (*GListLTrimRequest) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{23} +} + +func (x *GListLTrimRequest) GetKey() string { + if x != nil { + return x.Key + } + return "" +} + +func (x *GListLTrimRequest) GetStart() int32 { + if x != nil { + return x.Start + } + return 0 +} + +func (x *GListLTrimRequest) GetStop() int32 { + if x != nil { + return x.Stop + } + return 0 +} + +type GListLTrimResponse struct { + state protoimpl.MessageState + sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + + Ok bool `protobuf:"varint,1,opt,name=ok,proto3" json:"ok,omitempty"` +} + +func (x *GListLTrimResponse) Reset() { + *x = GListLTrimResponse{} + if protoimpl.UnsafeEnabled { + mi := &file_db_proto_msgTypes[24] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) + } +} + +func (x *GListLTrimResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*GListLTrimResponse) ProtoMessage() {} + +func (x *GListLTrimResponse) ProtoReflect() protoreflect.Message { + mi := &file_db_proto_msgTypes[24] + if protoimpl.UnsafeEnabled && x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use GListLTrimResponse.ProtoReflect.Descriptor instead. +func (*GListLTrimResponse) Descriptor() ([]byte, []int) { + return file_db_proto_rawDescGZIP(), []int{24} +} + +func (x *GListLTrimResponse) GetOk() bool { + if x != nil { + return x.Ok + } + return false +} + +var File_db_proto protoreflect.FileDescriptor + +var file_db_proto_rawDesc = []byte{ + 0x0a, 0x08, 0x64, 0x62, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x12, 0x05, 0x67, 0x6c, 0x69, 0x73, + 0x74, 0x22, 0xa4, 0x02, 0x0a, 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, 0x75, 0x73, 0x68, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, + 0x52, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, + 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, + 0x05, 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, + 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, + 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, + 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, + 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, + 0x48, 0x00, 0x52, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, + 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, + 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, + 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x24, 0x0a, 0x12, 0x47, 0x4c, 0x69, 0x73, + 0x74, 0x4c, 0x50, 0x75, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x22, 0x4c, + 0x0a, 0x12, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x71, + 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, + 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x24, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, + 0x18, 0x02, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x86, 0x02, 0x0a, + 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x53, + 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, + 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, + 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, + 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, + 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, + 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, + 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, + 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, 0x09, 0x42, 0x6f, + 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, + 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x42, 0x79, + 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, + 0x52, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, + 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x25, 0x0a, 0x13, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, + 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, + 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x22, 0xa4, 0x02, 0x0a, + 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x75, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x53, 0x74, 0x72, + 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, + 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, + 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, + 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, + 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, + 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, + 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x42, + 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, + 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, + 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, + 0x6c, 0x75, 0x65, 0x22, 0x24, 0x0a, 0x12, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x75, 0x73, + 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x22, 0x4c, 0x0a, 0x12, 0x47, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x50, 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, + 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, + 0x79, 0x12, 0x24, 0x0a, 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x02, 0x20, 0x03, 0x28, + 0x0b, 0x32, 0x0c, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, + 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x22, 0x25, 0x0a, 0x13, 0x47, 0x4c, 0x69, 0x73, 0x74, + 0x52, 0x50, 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, + 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x22, 0x24, + 0x0a, 0x10, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, + 0x03, 0x6b, 0x65, 0x79, 0x22, 0x92, 0x02, 0x0a, 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, + 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, + 0x00, 0x52, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, + 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, + 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, + 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, + 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, + 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, + 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, + 0x08, 0x48, 0x00, 0x52, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, + 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, + 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x24, 0x0a, 0x10, 0x47, 0x4c, 0x69, + 0x73, 0x74, 0x52, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, + 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, + 0x92, 0x02, 0x0a, 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x73, + 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x53, 0x74, + 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, + 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, + 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, + 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x48, + 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, + 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, + 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, + 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, 0x09, 0x42, 0x6f, 0x6f, + 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, + 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x42, 0x79, 0x74, + 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, + 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, + 0x61, 0x6c, 0x75, 0x65, 0x22, 0x50, 0x0a, 0x12, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x52, 0x61, + 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, + 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, + 0x73, 0x74, 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, + 0x72, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x73, 0x74, 0x6f, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, + 0x52, 0x04, 0x73, 0x74, 0x6f, 0x70, 0x22, 0x3b, 0x0a, 0x13, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x24, 0x0a, + 0x06, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x73, 0x18, 0x01, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0c, 0x2e, + 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x52, 0x06, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x73, 0x22, 0x24, 0x0a, 0x10, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x4c, 0x65, 0x6e, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x22, 0x3b, 0x0a, 0x11, 0x47, 0x4c, 0x69, + 0x73, 0x74, 0x4c, 0x4c, 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x16, + 0x0a, 0x06, 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x06, + 0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x02, 0x20, 0x01, + 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x22, 0xb9, 0x02, 0x0a, 0x10, 0x47, 0x4c, 0x69, 0x73, 0x74, + 0x4c, 0x52, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, + 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, + 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, + 0x75, 0x6e, 0x74, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x49, + 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, + 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, + 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x42, 0x6f, + 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x22, 0x39, 0x0a, 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x52, 0x65, 0x6d, 0x52, + 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x14, 0x0a, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x63, 0x6f, 0x75, 0x6e, 0x74, 0x12, 0x0e, 0x0a, + 0x02, 0x6f, 0x6b, 0x18, 0x02, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x22, 0x3c, 0x0a, + 0x12, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, + 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x18, 0x02, + 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x22, 0x94, 0x02, 0x0a, 0x13, + 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, + 0x75, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x53, 0x74, 0x72, 0x69, + 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x49, + 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, + 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, + 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, + 0x02, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x07, 0x20, 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, + 0x61, 0x6c, 0x75, 0x65, 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x42, 0x6f, + 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x42, + 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, + 0x75, 0x65, 0x22, 0xb9, 0x02, 0x0a, 0x10, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x53, 0x65, 0x74, + 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, 0x01, + 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x69, 0x6e, 0x64, + 0x65, 0x78, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x12, + 0x22, 0x0a, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x03, + 0x20, 0x01, 0x28, 0x09, 0x48, 0x00, 0x52, 0x0b, 0x53, 0x74, 0x72, 0x69, 0x6e, 0x67, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x05, 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, 0x33, 0x32, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x49, 0x6e, 0x74, 0x36, 0x34, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x03, 0x48, 0x00, 0x52, 0x0a, 0x49, 0x6e, 0x74, + 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, + 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x06, 0x20, 0x01, 0x28, 0x02, 0x48, 0x00, 0x52, + 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x33, 0x32, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x12, 0x24, 0x0a, + 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, 0x6c, 0x75, 0x65, 0x18, 0x07, 0x20, + 0x01, 0x28, 0x01, 0x48, 0x00, 0x52, 0x0c, 0x46, 0x6c, 0x6f, 0x61, 0x74, 0x36, 0x34, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x1e, 0x0a, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, 0x6c, 0x75, 0x65, + 0x18, 0x08, 0x20, 0x01, 0x28, 0x08, 0x48, 0x00, 0x52, 0x09, 0x42, 0x6f, 0x6f, 0x6c, 0x56, 0x61, + 0x6c, 0x75, 0x65, 0x12, 0x20, 0x0a, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, 0x56, 0x61, 0x6c, 0x75, + 0x65, 0x18, 0x09, 0x20, 0x01, 0x28, 0x0c, 0x48, 0x00, 0x52, 0x0a, 0x42, 0x79, 0x74, 0x65, 0x73, + 0x56, 0x61, 0x6c, 0x75, 0x65, 0x42, 0x07, 0x0a, 0x05, 0x76, 0x61, 0x6c, 0x75, 0x65, 0x22, 0x23, + 0x0a, 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x53, 0x65, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, + 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, + 0x02, 0x6f, 0x6b, 0x22, 0x4f, 0x0a, 0x11, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x54, 0x72, 0x69, + 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x12, 0x10, 0x0a, 0x03, 0x6b, 0x65, 0x79, 0x18, + 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x03, 0x6b, 0x65, 0x79, 0x12, 0x14, 0x0a, 0x05, 0x73, 0x74, + 0x61, 0x72, 0x74, 0x18, 0x02, 0x20, 0x01, 0x28, 0x05, 0x52, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, + 0x12, 0x12, 0x0a, 0x04, 0x73, 0x74, 0x6f, 0x70, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04, + 0x73, 0x74, 0x6f, 0x70, 0x22, 0x24, 0x0a, 0x12, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x54, 0x72, + 0x69, 0x6d, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x0e, 0x0a, 0x02, 0x6f, 0x6b, + 0x18, 0x01, 0x20, 0x01, 0x28, 0x08, 0x52, 0x02, 0x6f, 0x6b, 0x32, 0x8b, 0x06, 0x0a, 0x0c, 0x47, + 0x4c, 0x69, 0x73, 0x74, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x3e, 0x0a, 0x05, 0x4c, + 0x50, 0x75, 0x73, 0x68, 0x12, 0x18, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, + 0x73, 0x74, 0x4c, 0x50, 0x75, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, + 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, 0x75, 0x73, + 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x41, 0x0a, 0x06, 0x4c, + 0x50, 0x75, 0x73, 0x68, 0x73, 0x12, 0x19, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, + 0x69, 0x73, 0x74, 0x4c, 0x50, 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1a, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, + 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x3e, + 0x0a, 0x05, 0x52, 0x50, 0x75, 0x73, 0x68, 0x12, 0x18, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, + 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x75, 0x73, 0x68, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, + 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, + 0x50, 0x75, 0x73, 0x68, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x41, + 0x0a, 0x06, 0x52, 0x50, 0x75, 0x73, 0x68, 0x73, 0x12, 0x19, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, + 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x71, 0x75, + 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, + 0x74, 0x52, 0x50, 0x75, 0x73, 0x68, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, + 0x00, 0x12, 0x3b, 0x0a, 0x04, 0x4c, 0x50, 0x6f, 0x70, 0x12, 0x17, 0x2e, 0x67, 0x6c, 0x69, 0x73, + 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, + 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, + 0x4c, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x3b, + 0x0a, 0x04, 0x52, 0x50, 0x6f, 0x70, 0x12, 0x17, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, + 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x6f, 0x70, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x18, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x52, 0x50, 0x6f, + 0x70, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x41, 0x0a, 0x06, 0x4c, + 0x52, 0x61, 0x6e, 0x67, 0x65, 0x12, 0x19, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, + 0x69, 0x73, 0x74, 0x4c, 0x52, 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, + 0x1a, 0x1a, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x52, + 0x61, 0x6e, 0x67, 0x65, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x3b, + 0x0a, 0x04, 0x4c, 0x4c, 0x65, 0x6e, 0x12, 0x17, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, + 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x4c, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, + 0x18, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x4c, 0x65, + 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x3b, 0x0a, 0x04, 0x4c, + 0x52, 0x65, 0x6d, 0x12, 0x17, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, + 0x74, 0x4c, 0x52, 0x65, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, + 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x52, 0x65, 0x6d, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x41, 0x0a, 0x06, 0x4c, 0x49, 0x6e, 0x64, + 0x65, 0x78, 0x12, 0x19, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, + 0x4c, 0x49, 0x6e, 0x64, 0x65, 0x78, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, + 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x49, 0x6e, 0x64, 0x65, + 0x78, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x3b, 0x0a, 0x04, 0x4c, + 0x53, 0x65, 0x74, 0x12, 0x17, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, + 0x74, 0x4c, 0x53, 0x65, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x18, 0x2e, 0x67, + 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x53, 0x65, 0x74, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x12, 0x3e, 0x0a, 0x05, 0x4c, 0x54, 0x72, 0x69, + 0x6d, 0x12, 0x18, 0x2e, 0x67, 0x6c, 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, + 0x54, 0x72, 0x69, 0x6d, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x19, 0x2e, 0x67, 0x6c, + 0x69, 0x73, 0x74, 0x2e, 0x47, 0x4c, 0x69, 0x73, 0x74, 0x4c, 0x54, 0x72, 0x69, 0x6d, 0x52, 0x65, + 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x3b, 0x67, 0x6c, + 0x69, 0x73, 0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33, +} + +var ( + file_db_proto_rawDescOnce sync.Once + file_db_proto_rawDescData = file_db_proto_rawDesc +) + +func file_db_proto_rawDescGZIP() []byte { + file_db_proto_rawDescOnce.Do(func() { + file_db_proto_rawDescData = protoimpl.X.CompressGZIP(file_db_proto_rawDescData) + }) + return file_db_proto_rawDescData +} + +var file_db_proto_msgTypes = make([]protoimpl.MessageInfo, 25) +var file_db_proto_goTypes = []interface{}{ + (*GListLPushRequest)(nil), // 0: glist.GListLPushRequest + (*GListLPushResponse)(nil), // 1: glist.GListLPushResponse + (*GListLPushsRequest)(nil), // 2: glist.GListLPushsRequest + (*Value)(nil), // 3: glist.value + (*GListLPushsResponse)(nil), // 4: glist.GListLPushsResponse + (*GListRPushRequest)(nil), // 5: glist.GListRPushRequest + (*GListRPushResponse)(nil), // 6: glist.GListRPushResponse + (*GListRPushsRequest)(nil), // 7: glist.GListRPushsRequest + (*GListRPushsResponse)(nil), // 8: glist.GListRPushsResponse + (*GListLPopRequest)(nil), // 9: glist.GListLPopRequest + (*GListLPopResponse)(nil), // 10: glist.GListLPopResponse + (*GListRPopRequest)(nil), // 11: glist.GListRPopRequest + (*GListRPopResponse)(nil), // 12: glist.GListRPopResponse + (*GListLRangeRequest)(nil), // 13: glist.GListLRangeRequest + (*GListLRangeResponse)(nil), // 14: glist.GListLRangeResponse + (*GListLLenRequest)(nil), // 15: glist.GListLLenRequest + (*GListLLenResponse)(nil), // 16: glist.GListLLenResponse + (*GListLRemRequest)(nil), // 17: glist.GListLRemRequest + (*GListLRemResponse)(nil), // 18: glist.GListLRemResponse + (*GListLIndexRequest)(nil), // 19: glist.GListLIndexRequest + (*GListLIndexResponse)(nil), // 20: glist.GListLIndexResponse + (*GListLSetRequest)(nil), // 21: glist.GListLSetRequest + (*GListLSetResponse)(nil), // 22: glist.GListLSetResponse + (*GListLTrimRequest)(nil), // 23: glist.GListLTrimRequest + (*GListLTrimResponse)(nil), // 24: glist.GListLTrimResponse +} +var file_db_proto_depIdxs = []int32{ + 3, // 0: glist.GListLPushsRequest.values:type_name -> glist.value + 3, // 1: glist.GListRPushsRequest.values:type_name -> glist.value + 3, // 2: glist.GListLRangeResponse.values:type_name -> glist.value + 0, // 3: glist.GListService.LPush:input_type -> glist.GListLPushRequest + 2, // 4: glist.GListService.LPushs:input_type -> glist.GListLPushsRequest + 5, // 5: glist.GListService.RPush:input_type -> glist.GListRPushRequest + 7, // 6: glist.GListService.RPushs:input_type -> glist.GListRPushsRequest + 9, // 7: glist.GListService.LPop:input_type -> glist.GListLPopRequest + 11, // 8: glist.GListService.RPop:input_type -> glist.GListRPopRequest + 13, // 9: glist.GListService.LRange:input_type -> glist.GListLRangeRequest + 15, // 10: glist.GListService.LLen:input_type -> glist.GListLLenRequest + 17, // 11: glist.GListService.LRem:input_type -> glist.GListLRemRequest + 19, // 12: glist.GListService.LIndex:input_type -> glist.GListLIndexRequest + 21, // 13: glist.GListService.LSet:input_type -> glist.GListLSetRequest + 23, // 14: glist.GListService.LTrim:input_type -> glist.GListLTrimRequest + 1, // 15: glist.GListService.LPush:output_type -> glist.GListLPushResponse + 4, // 16: glist.GListService.LPushs:output_type -> glist.GListLPushsResponse + 6, // 17: glist.GListService.RPush:output_type -> glist.GListRPushResponse + 8, // 18: glist.GListService.RPushs:output_type -> glist.GListRPushsResponse + 10, // 19: glist.GListService.LPop:output_type -> glist.GListLPopResponse + 12, // 20: glist.GListService.RPop:output_type -> glist.GListRPopResponse + 14, // 21: glist.GListService.LRange:output_type -> glist.GListLRangeResponse + 16, // 22: glist.GListService.LLen:output_type -> glist.GListLLenResponse + 18, // 23: glist.GListService.LRem:output_type -> glist.GListLRemResponse + 20, // 24: glist.GListService.LIndex:output_type -> glist.GListLIndexResponse + 22, // 25: glist.GListService.LSet:output_type -> glist.GListLSetResponse + 24, // 26: glist.GListService.LTrim:output_type -> glist.GListLTrimResponse + 15, // [15:27] is the sub-list for method output_type + 3, // [3:15] is the sub-list for method input_type + 3, // [3:3] is the sub-list for extension type_name + 3, // [3:3] is the sub-list for extension extendee + 0, // [0:3] is the sub-list for field type_name +} + +func init() { file_db_proto_init() } +func file_db_proto_init() { + if File_db_proto != nil { return } + if !protoimpl.UnsafeEnabled { + file_db_proto_msgTypes[0].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLPushRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[1].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLPushResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[2].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLPushsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[3].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*Value); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[4].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLPushsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[5].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListRPushRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[6].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListRPushResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[7].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListRPushsRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[8].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListRPushsResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[9].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLPopRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[10].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLPopResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[11].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListRPopRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[12].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListRPopResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[13].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLRangeRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[14].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLRangeResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[15].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLLenRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[16].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLLenResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[17].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLRemRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[18].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLRemResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[19].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLIndexRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[20].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLIndexResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[21].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLSetRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[22].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLSetResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[23].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLTrimRequest); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + file_db_proto_msgTypes[24].Exporter = func(v interface{}, i int) interface{} { + switch v := v.(*GListLTrimResponse); i { + case 0: + return &v.state + case 1: + return &v.sizeCache + case 2: + return &v.unknownFields + default: + return nil + } + } + } + file_db_proto_msgTypes[0].OneofWrappers = []interface{}{ + (*GListLPushRequest_StringValue)(nil), + (*GListLPushRequest_Int32Value)(nil), + (*GListLPushRequest_Int64Value)(nil), + (*GListLPushRequest_Float32Value)(nil), + (*GListLPushRequest_Float64Value)(nil), + (*GListLPushRequest_BoolValue)(nil), + (*GListLPushRequest_BytesValue)(nil), + } + file_db_proto_msgTypes[3].OneofWrappers = []interface{}{ + (*Value_StringValue)(nil), + (*Value_Int32Value)(nil), + (*Value_Int64Value)(nil), + (*Value_Float32Value)(nil), + (*Value_Float64Value)(nil), + (*Value_BoolValue)(nil), + (*Value_BytesValue)(nil), + } + file_db_proto_msgTypes[5].OneofWrappers = []interface{}{ + (*GListRPushRequest_StringValue)(nil), + (*GListRPushRequest_Int32Value)(nil), + (*GListRPushRequest_Int64Value)(nil), + (*GListRPushRequest_Float32Value)(nil), + (*GListRPushRequest_Float64Value)(nil), + (*GListRPushRequest_BoolValue)(nil), + (*GListRPushRequest_BytesValue)(nil), + } + file_db_proto_msgTypes[10].OneofWrappers = []interface{}{ + (*GListLPopResponse_StringValue)(nil), + (*GListLPopResponse_Int32Value)(nil), + (*GListLPopResponse_Int64Value)(nil), + (*GListLPopResponse_Float32Value)(nil), + (*GListLPopResponse_Float64Value)(nil), + (*GListLPopResponse_BoolValue)(nil), + (*GListLPopResponse_BytesValue)(nil), + } + file_db_proto_msgTypes[12].OneofWrappers = []interface{}{ + (*GListRPopResponse_StringValue)(nil), + (*GListRPopResponse_Int32Value)(nil), + (*GListRPopResponse_Int64Value)(nil), + (*GListRPopResponse_Float32Value)(nil), + (*GListRPopResponse_Float64Value)(nil), + (*GListRPopResponse_BoolValue)(nil), + (*GListRPopResponse_BytesValue)(nil), + } + file_db_proto_msgTypes[17].OneofWrappers = []interface{}{ + (*GListLRemRequest_StringValue)(nil), + (*GListLRemRequest_Int32Value)(nil), + (*GListLRemRequest_Int64Value)(nil), + (*GListLRemRequest_Float32Value)(nil), + (*GListLRemRequest_Float64Value)(nil), + (*GListLRemRequest_BoolValue)(nil), + (*GListLRemRequest_BytesValue)(nil), + } + file_db_proto_msgTypes[20].OneofWrappers = []interface{}{ + (*GListLIndexResponse_StringValue)(nil), + (*GListLIndexResponse_Int32Value)(nil), + (*GListLIndexResponse_Int64Value)(nil), + (*GListLIndexResponse_Float32Value)(nil), + (*GListLIndexResponse_Float64Value)(nil), + (*GListLIndexResponse_BoolValue)(nil), + (*GListLIndexResponse_BytesValue)(nil), + } + file_db_proto_msgTypes[21].OneofWrappers = []interface{}{ + (*GListLSetRequest_StringValue)(nil), + (*GListLSetRequest_Int32Value)(nil), + (*GListLSetRequest_Int64Value)(nil), + (*GListLSetRequest_Float32Value)(nil), + (*GListLSetRequest_Float64Value)(nil), + (*GListLSetRequest_BoolValue)(nil), + (*GListLSetRequest_BytesValue)(nil), + } type x struct{} out := protoimpl.TypeBuilder{ File: protoimpl.DescBuilder{ GoPackagePath: reflect.TypeOf(x{}).PkgPath(), - RawDescriptor: file_lib_proto_glist_db_proto_rawDesc, + RawDescriptor: file_db_proto_rawDesc, NumEnums: 0, - NumMessages: 0, + NumMessages: 25, NumExtensions: 0, NumServices: 1, }, - GoTypes: file_lib_proto_glist_db_proto_goTypes, - DependencyIndexes: file_lib_proto_glist_db_proto_depIdxs, + GoTypes: file_db_proto_goTypes, + DependencyIndexes: file_db_proto_depIdxs, + MessageInfos: file_db_proto_msgTypes, }.Build() - File_lib_proto_glist_db_proto = out.File - file_lib_proto_glist_db_proto_rawDesc = nil - file_lib_proto_glist_db_proto_goTypes = nil - file_lib_proto_glist_db_proto_depIdxs = nil + File_db_proto = out.File + file_db_proto_rawDesc = nil + file_db_proto_goTypes = nil + file_db_proto_depIdxs = nil } diff --git a/lib/proto/glist/db.proto b/lib/proto/glist/db.proto index 1623c302..c1e19836 100644 --- a/lib/proto/glist/db.proto +++ b/lib/proto/glist/db.proto @@ -1,9 +1,199 @@ syntax = "proto3"; package glist; -option go_package = "flydb/lib/proto/glist"; +option go_package = ".;glist"; service GListService { // example - //rpc Get(GListGetRequest) returns (GListGetResponse) {} + rpc LPush(GListLPushRequest) returns (GListLPushResponse) {} + rpc LPushs(GListLPushsRequest) returns (GListLPushsResponse) {} + rpc RPush(GListRPushRequest) returns (GListRPushResponse) {} + rpc RPushs(GListRPushsRequest) returns (GListRPushsResponse) {} + rpc LPop(GListLPopRequest) returns (GListLPopResponse) {} + rpc RPop(GListRPopRequest) returns (GListRPopResponse) {} + rpc LRange(GListLRangeRequest) returns (GListLRangeResponse) {} + rpc LLen(GListLLenRequest) returns (GListLLenResponse) {} + rpc LRem(GListLRemRequest) returns (GListLRemResponse) {} + rpc LIndex(GListLIndexRequest) returns (GListLIndexResponse) {} + rpc LSet(GListLSetRequest) returns (GListLSetResponse) {} + rpc LTrim(GListLTrimRequest) returns (GListLTrimResponse) {} +} + +message GListLPushRequest { + string key = 1; + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListLPushResponse { + bool ok = 1; +} + +message GListLPushsRequest { + string key = 1; + repeated value values = 2; +} + +message value { + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListLPushsResponse { + bool ok = 1; +} + +message GListRPushRequest { + string key = 1; + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListRPushResponse { + bool ok = 1; +} + +message GListRPushsRequest { + string key = 1; + repeated value values = 2; +} + +message GListRPushsResponse { + bool ok = 1; +} + +message GListLPopRequest { + string key = 1; +} + +message GListLPopResponse { + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListRPopRequest { + string key = 1; +} + +message GListRPopResponse { + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListLRangeRequest { + string key = 1; + int32 start = 2; + int32 stop = 3; +} + +message GListLRangeResponse { + repeated value values = 1; +} + +message GListLLenRequest { + string key = 1; +} + +message GListLLenResponse { + int32 length = 1; + bool ok = 2; +} + +message GListLRemRequest { + string key = 1; + int32 count = 2; + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListLRemResponse { + int32 count = 1; + bool ok = 2; +} + +message GListLIndexRequest { + string key = 1; + int32 index = 2; +} + +message GListLIndexResponse { + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListLSetRequest { + string key = 1; + int32 index = 2; + oneof value { + string StringValue = 3; + int32 Int32Value = 4; + int64 Int64Value = 5; + float Float32Value = 6; + double Float64Value = 7; + bool BoolValue = 8; + bytes BytesValue = 9; + }; +} + +message GListLSetResponse { + bool ok = 1; +} + +message GListLTrimRequest { + string key = 1; + int32 start = 2; + int32 stop = 3; +} + +message GListLTrimResponse { + bool ok = 1; } diff --git a/lib/proto/glist/db_grpc.pb.go b/lib/proto/glist/db_grpc.pb.go index 01e235c2..3b8f7c71 100644 --- a/lib/proto/glist/db_grpc.pb.go +++ b/lib/proto/glist/db_grpc.pb.go @@ -2,12 +2,15 @@ // versions: // - protoc-gen-go-grpc v1.2.0 // - protoc v3.6.1 -// source: lib/proto/glist/db.proto +// source: db.proto package glist import ( + context "context" grpc "google.golang.org/grpc" + codes "google.golang.org/grpc/codes" + status "google.golang.org/grpc/status" ) // This is a compile-time assertion to ensure that this generated file @@ -19,6 +22,19 @@ const _ = grpc.SupportPackageIsVersion7 // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream. type GListServiceClient interface { + // example + LPush(ctx context.Context, in *GListLPushRequest, opts ...grpc.CallOption) (*GListLPushResponse, error) + LPushs(ctx context.Context, in *GListLPushsRequest, opts ...grpc.CallOption) (*GListLPushsResponse, error) + RPush(ctx context.Context, in *GListRPushRequest, opts ...grpc.CallOption) (*GListRPushResponse, error) + RPushs(ctx context.Context, in *GListRPushsRequest, opts ...grpc.CallOption) (*GListRPushsResponse, error) + LPop(ctx context.Context, in *GListLPopRequest, opts ...grpc.CallOption) (*GListLPopResponse, error) + RPop(ctx context.Context, in *GListRPopRequest, opts ...grpc.CallOption) (*GListRPopResponse, error) + LRange(ctx context.Context, in *GListLRangeRequest, opts ...grpc.CallOption) (*GListLRangeResponse, error) + LLen(ctx context.Context, in *GListLLenRequest, opts ...grpc.CallOption) (*GListLLenResponse, error) + LRem(ctx context.Context, in *GListLRemRequest, opts ...grpc.CallOption) (*GListLRemResponse, error) + LIndex(ctx context.Context, in *GListLIndexRequest, opts ...grpc.CallOption) (*GListLIndexResponse, error) + LSet(ctx context.Context, in *GListLSetRequest, opts ...grpc.CallOption) (*GListLSetResponse, error) + LTrim(ctx context.Context, in *GListLTrimRequest, opts ...grpc.CallOption) (*GListLTrimResponse, error) } type gListServiceClient struct { @@ -29,10 +45,131 @@ func NewGListServiceClient(cc grpc.ClientConnInterface) GListServiceClient { return &gListServiceClient{cc} } +func (c *gListServiceClient) LPush(ctx context.Context, in *GListLPushRequest, opts ...grpc.CallOption) (*GListLPushResponse, error) { + out := new(GListLPushResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LPush", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LPushs(ctx context.Context, in *GListLPushsRequest, opts ...grpc.CallOption) (*GListLPushsResponse, error) { + out := new(GListLPushsResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LPushs", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) RPush(ctx context.Context, in *GListRPushRequest, opts ...grpc.CallOption) (*GListRPushResponse, error) { + out := new(GListRPushResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/RPush", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) RPushs(ctx context.Context, in *GListRPushsRequest, opts ...grpc.CallOption) (*GListRPushsResponse, error) { + out := new(GListRPushsResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/RPushs", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LPop(ctx context.Context, in *GListLPopRequest, opts ...grpc.CallOption) (*GListLPopResponse, error) { + out := new(GListLPopResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LPop", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) RPop(ctx context.Context, in *GListRPopRequest, opts ...grpc.CallOption) (*GListRPopResponse, error) { + out := new(GListRPopResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/RPop", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LRange(ctx context.Context, in *GListLRangeRequest, opts ...grpc.CallOption) (*GListLRangeResponse, error) { + out := new(GListLRangeResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LRange", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LLen(ctx context.Context, in *GListLLenRequest, opts ...grpc.CallOption) (*GListLLenResponse, error) { + out := new(GListLLenResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LLen", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LRem(ctx context.Context, in *GListLRemRequest, opts ...grpc.CallOption) (*GListLRemResponse, error) { + out := new(GListLRemResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LRem", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LIndex(ctx context.Context, in *GListLIndexRequest, opts ...grpc.CallOption) (*GListLIndexResponse, error) { + out := new(GListLIndexResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LIndex", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LSet(ctx context.Context, in *GListLSetRequest, opts ...grpc.CallOption) (*GListLSetResponse, error) { + out := new(GListLSetResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LSet", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *gListServiceClient) LTrim(ctx context.Context, in *GListLTrimRequest, opts ...grpc.CallOption) (*GListLTrimResponse, error) { + out := new(GListLTrimResponse) + err := c.cc.Invoke(ctx, "/glist.GListService/LTrim", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // GListServiceServer is the server API for GListService service. // All implementations must embed UnimplementedGListServiceServer // for forward compatibility type GListServiceServer interface { + // example + LPush(context.Context, *GListLPushRequest) (*GListLPushResponse, error) + LPushs(context.Context, *GListLPushsRequest) (*GListLPushsResponse, error) + RPush(context.Context, *GListRPushRequest) (*GListRPushResponse, error) + RPushs(context.Context, *GListRPushsRequest) (*GListRPushsResponse, error) + LPop(context.Context, *GListLPopRequest) (*GListLPopResponse, error) + RPop(context.Context, *GListRPopRequest) (*GListRPopResponse, error) + LRange(context.Context, *GListLRangeRequest) (*GListLRangeResponse, error) + LLen(context.Context, *GListLLenRequest) (*GListLLenResponse, error) + LRem(context.Context, *GListLRemRequest) (*GListLRemResponse, error) + LIndex(context.Context, *GListLIndexRequest) (*GListLIndexResponse, error) + LSet(context.Context, *GListLSetRequest) (*GListLSetResponse, error) + LTrim(context.Context, *GListLTrimRequest) (*GListLTrimResponse, error) mustEmbedUnimplementedGListServiceServer() } @@ -40,6 +177,42 @@ type GListServiceServer interface { type UnimplementedGListServiceServer struct { } +func (UnimplementedGListServiceServer) LPush(context.Context, *GListLPushRequest) (*GListLPushResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LPush not implemented") +} +func (UnimplementedGListServiceServer) LPushs(context.Context, *GListLPushsRequest) (*GListLPushsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LPushs not implemented") +} +func (UnimplementedGListServiceServer) RPush(context.Context, *GListRPushRequest) (*GListRPushResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RPush not implemented") +} +func (UnimplementedGListServiceServer) RPushs(context.Context, *GListRPushsRequest) (*GListRPushsResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RPushs not implemented") +} +func (UnimplementedGListServiceServer) LPop(context.Context, *GListLPopRequest) (*GListLPopResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LPop not implemented") +} +func (UnimplementedGListServiceServer) RPop(context.Context, *GListRPopRequest) (*GListRPopResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RPop not implemented") +} +func (UnimplementedGListServiceServer) LRange(context.Context, *GListLRangeRequest) (*GListLRangeResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LRange not implemented") +} +func (UnimplementedGListServiceServer) LLen(context.Context, *GListLLenRequest) (*GListLLenResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LLen not implemented") +} +func (UnimplementedGListServiceServer) LRem(context.Context, *GListLRemRequest) (*GListLRemResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LRem not implemented") +} +func (UnimplementedGListServiceServer) LIndex(context.Context, *GListLIndexRequest) (*GListLIndexResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LIndex not implemented") +} +func (UnimplementedGListServiceServer) LSet(context.Context, *GListLSetRequest) (*GListLSetResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LSet not implemented") +} +func (UnimplementedGListServiceServer) LTrim(context.Context, *GListLTrimRequest) (*GListLTrimResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method LTrim not implemented") +} func (UnimplementedGListServiceServer) mustEmbedUnimplementedGListServiceServer() {} // UnsafeGListServiceServer may be embedded to opt out of forward compatibility for this service. @@ -53,13 +226,278 @@ func RegisterGListServiceServer(s grpc.ServiceRegistrar, srv GListServiceServer) s.RegisterService(&GListService_ServiceDesc, srv) } +func _GListService_LPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLPushRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LPush(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LPush", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LPush(ctx, req.(*GListLPushRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LPushs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLPushsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LPushs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LPushs", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LPushs(ctx, req.(*GListLPushsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_RPush_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListRPushRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).RPush(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/RPush", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).RPush(ctx, req.(*GListRPushRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_RPushs_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListRPushsRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).RPushs(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/RPushs", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).RPushs(ctx, req.(*GListRPushsRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LPop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLPopRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LPop(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LPop", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LPop(ctx, req.(*GListLPopRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_RPop_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListRPopRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).RPop(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/RPop", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).RPop(ctx, req.(*GListRPopRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLRangeRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LRange(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LRange", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LRange(ctx, req.(*GListLRangeRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LLen_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLLenRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LLen(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LLen", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LLen(ctx, req.(*GListLLenRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LRem_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLRemRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LRem(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LRem", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LRem(ctx, req.(*GListLRemRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LIndex_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLIndexRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LIndex(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LIndex", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LIndex(ctx, req.(*GListLIndexRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LSet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLSetRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LSet(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LSet", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LSet(ctx, req.(*GListLSetRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _GListService_LTrim_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GListLTrimRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(GListServiceServer).LTrim(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/glist.GListService/LTrim", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(GListServiceServer).LTrim(ctx, req.(*GListLTrimRequest)) + } + return interceptor(ctx, in, info, handler) +} + // GListService_ServiceDesc is the grpc.ServiceDesc for GListService service. // It's only intended for direct use with grpc.RegisterService, // and not to be introspected or modified (even as a copy) var GListService_ServiceDesc = grpc.ServiceDesc{ ServiceName: "glist.GListService", HandlerType: (*GListServiceServer)(nil), - Methods: []grpc.MethodDesc{}, - Streams: []grpc.StreamDesc{}, - Metadata: "lib/proto/glist/db.proto", + Methods: []grpc.MethodDesc{ + { + MethodName: "LPush", + Handler: _GListService_LPush_Handler, + }, + { + MethodName: "LPushs", + Handler: _GListService_LPushs_Handler, + }, + { + MethodName: "RPush", + Handler: _GListService_RPush_Handler, + }, + { + MethodName: "RPushs", + Handler: _GListService_RPushs_Handler, + }, + { + MethodName: "LPop", + Handler: _GListService_LPop_Handler, + }, + { + MethodName: "RPop", + Handler: _GListService_RPop_Handler, + }, + { + MethodName: "LRange", + Handler: _GListService_LRange_Handler, + }, + { + MethodName: "LLen", + Handler: _GListService_LLen_Handler, + }, + { + MethodName: "LRem", + Handler: _GListService_LRem_Handler, + }, + { + MethodName: "LIndex", + Handler: _GListService_LIndex_Handler, + }, + { + MethodName: "LSet", + Handler: _GListService_LSet_Handler, + }, + { + MethodName: "LTrim", + Handler: _GListService_LTrim_Handler, + }, + }, + Streams: []grpc.StreamDesc{}, + Metadata: "db.proto", }