cerc-io/laconicd
18
0
Fork 1
Code Issues 21 Pull Requests Actions Packages Projects Releases 3 Wiki Activity

Implement float, boolean and reference types for attributes keyValueInput

Browse Source
This commit is contained in:
nabarun 2022-04-18 18:04:52 +05:30
parent f7623b26f9
commit 8477b3d9cb
4 changed files with 579 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
gql/util.go
View File

@ -279,12 +279,35 @@ func parseRequestAttributes(attrs []*KeyValueInput) []*nstypes.QueryListRecordsR
if value.Value.String != nil {
kvPair.Value.String_ = *value.Value.String
kvPair.Value.Type = "string"
}
if value.Value.Int != nil {
kvPair.Value.Int = int64(*value.Value.Int)
kvPair.Value.Type = "int"
}
if value.Value.Float != nil {
kvPair.Value.Float = *value.Value.Float
kvPair.Value.Type = "float"
}
if value.Value.Boolean != nil {
kvPair.Value.Boolean = *value.Value.Boolean
kvPair.Value.Type = "boolean"
}
if value.Value.Reference != nil {
reference := &nstypes.QueryListRecordsRequest_ReferenceInput{
Id: value.Value.Reference.ID,
}
kvPair.Value.Reference = reference
kvPair.Value.Type = "reference"
}
// TODO: Handle arrays.
kvPairs = append(kvPairs, kvPair)
}

12
proto/vulcanize/nameservice/v1beta1/query.proto
View File

@ -68,9 +68,17 @@ message QueryParamsResponse{
// QueryListRecordsRequest is request type for nameservice records list
message QueryListRecordsRequest{
message ReferenceInput {
string id = 1;
}
message ValueInput {
string string = 1;
int64 int = 2;
string type = 1;
string string = 2;
int64 int = 3;
double float = 4;
bool boolean = 5;
ReferenceInput reference = 6;
repeated ValueInput values = 7;
}
message KeyValueInput {
string key = 1;

38
x/nameservice/keeper/grpc_query.go
View File

@ -170,14 +170,21 @@ func MatchOnAttributes(record *types.RecordType, attributes []*types.QueryListRe
return false
}
if attr.Value.Int != 0 {
if attr.Value.Type == "int" {
recAttrValInt, ok := recAttrVal.(int)
if !ok || int(attr.Value.GetInt()) != recAttrValInt {
return false
}
}
if attr.Value.String_ != "" {
if attr.Value.Type == "float" {
recAttrValFloat, ok := recAttrVal.(float64)
if !ok || attr.Value.GetFloat() != recAttrValFloat {
return false
}
}
if attr.Value.Type == "string" {
recAttrValString, ok := recAttrVal.(string)
if !ok {
return false
@ -188,7 +195,32 @@ func MatchOnAttributes(record *types.RecordType, attributes []*types.QueryListRe
}
}
// TODO: Handle other attribute value types.
if attr.Value.Type == "boolean" {
recAttrValBool, ok := recAttrVal.(bool)
if !ok || attr.Value.GetBoolean() != recAttrValBool {
return false
}
}
if attr.Value.Type == "reference" {
obj, ok := recAttrVal.(map[string]interface{})
if !ok {
// Attr value is not an object.
return false
}
if _, ok := obj["/"].(string); !ok {
// Attr value is not a reference.
return false
}
recAttrValRefID := obj["/"].(string)
if recAttrValRefID != attr.Value.GetReference().GetId() {
return false
}
}
// TODO: Handle arrays.
}
return true

601
x/nameservice/types/query.pb.go generated
View File

@ -5,6 +5,7 @@ package types
import (
context "context"
encoding_binary "encoding/binary"
fmt "fmt"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
types "github.com/cosmos/cosmos-sdk/types"
@ -176,16 +177,67 @@ func (m *QueryListRecordsRequest) GetPagination() *query.PageRequest {
return nil
}
type QueryListRecordsRequest_ReferenceInput struct {
Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
}
func (m *QueryListRecordsRequest_ReferenceInput) Reset() {
*m = QueryListRecordsRequest_ReferenceInput{}
}
func (m *QueryListRecordsRequest_ReferenceInput) String() string { return proto.CompactTextString(m) }
func (*QueryListRecordsRequest_ReferenceInput) ProtoMessage() {}
func (*QueryListRecordsRequest_ReferenceInput) Descriptor() ([]byte, []int) {
return fileDescriptor_73d2465766c8f876, []int{2, 0}
}
func (m *QueryListRecordsRequest_ReferenceInput) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *QueryListRecordsRequest_ReferenceInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_QueryListRecordsRequest_ReferenceInput.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *QueryListRecordsRequest_ReferenceInput) XXX_Merge(src proto.Message) {
xxx_messageInfo_QueryListRecordsRequest_ReferenceInput.Merge(m, src)
}
func (m *QueryListRecordsRequest_ReferenceInput) XXX_Size() int {
return m.Size()
}
func (m *QueryListRecordsRequest_ReferenceInput) XXX_DiscardUnknown() {
xxx_messageInfo_QueryListRecordsRequest_ReferenceInput.DiscardUnknown(m)
}
var xxx_messageInfo_QueryListRecordsRequest_ReferenceInput proto.InternalMessageInfo
func (m *QueryListRecordsRequest_ReferenceInput) GetId() string {
if m != nil {
return m.Id
}
return ""
}
type QueryListRecordsRequest_ValueInput struct {
String_ string `protobuf:"bytes,1,opt,name=string,proto3" json:"string,omitempty"`
Int int64 `protobuf:"varint,2,opt,name=int,proto3" json:"int,omitempty"`
Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
String_ string `protobuf:"bytes,2,opt,name=string,proto3" json:"string,omitempty"`
Int int64 `protobuf:"varint,3,opt,name=int,proto3" json:"int,omitempty"`
Float float64 `protobuf:"fixed64,4,opt,name=float,proto3" json:"float,omitempty"`
Boolean bool `protobuf:"varint,5,opt,name=boolean,proto3" json:"boolean,omitempty"`
Reference *QueryListRecordsRequest_ReferenceInput `protobuf:"bytes,6,opt,name=reference,proto3" json:"reference,omitempty"`
Values []*QueryListRecordsRequest_ValueInput `protobuf:"bytes,7,rep,name=values,proto3" json:"values,omitempty"`
}
func (m *QueryListRecordsRequest_ValueInput) Reset() { *m = QueryListRecordsRequest_ValueInput{} }
func (m *QueryListRecordsRequest_ValueInput) String() string { return proto.CompactTextString(m) }
func (*QueryListRecordsRequest_ValueInput) ProtoMessage() {}
func (*QueryListRecordsRequest_ValueInput) Descriptor() ([]byte, []int) {
return fileDescriptor_73d2465766c8f876, []int{2, 0}
return fileDescriptor_73d2465766c8f876, []int{2, 1}
}
func (m *QueryListRecordsRequest_ValueInput) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -214,6 +266,13 @@ func (m *QueryListRecordsRequest_ValueInput) XXX_DiscardUnknown() {
var xxx_messageInfo_QueryListRecordsRequest_ValueInput proto.InternalMessageInfo
func (m *QueryListRecordsRequest_ValueInput) GetType() string {
if m != nil {
return m.Type
}
return ""
}
func (m *QueryListRecordsRequest_ValueInput) GetString_() string {
if m != nil {
return m.String_
@ -228,6 +287,34 @@ func (m *QueryListRecordsRequest_ValueInput) GetInt() int64 {
return 0
}
func (m *QueryListRecordsRequest_ValueInput) GetFloat() float64 {
if m != nil {
return m.Float
}
return 0
}
func (m *QueryListRecordsRequest_ValueInput) GetBoolean() bool {
if m != nil {
return m.Boolean
}
return false
}
func (m *QueryListRecordsRequest_ValueInput) GetReference() *QueryListRecordsRequest_ReferenceInput {
if m != nil {
return m.Reference
}
return nil
}
func (m *QueryListRecordsRequest_ValueInput) GetValues() []*QueryListRecordsRequest_ValueInput {
if m != nil {
return m.Values
}
return nil
}
type QueryListRecordsRequest_KeyValueInput struct {
Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
Value *QueryListRecordsRequest_ValueInput `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
@ -237,7 +324,7 @@ func (m *QueryListRecordsRequest_KeyValueInput) Reset() { *m = QueryList
func (m *QueryListRecordsRequest_KeyValueInput) String() string { return proto.CompactTextString(m) }
func (*QueryListRecordsRequest_KeyValueInput) ProtoMessage() {}
func (*QueryListRecordsRequest_KeyValueInput) Descriptor() ([]byte, []int) {
return fileDescriptor_73d2465766c8f876, []int{2, 1}
return fileDescriptor_73d2465766c8f876, []int{2, 2}
}
func (m *QueryListRecordsRequest_KeyValueInput) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
@ -1294,6 +1381,7 @@ func init() {
proto.RegisterType((*QueryParamsRequest)(nil), "vulcanize.nameservice.v1beta1.QueryParamsRequest")
proto.RegisterType((*QueryParamsResponse)(nil), "vulcanize.nameservice.v1beta1.QueryParamsResponse")
proto.RegisterType((*QueryListRecordsRequest)(nil), "vulcanize.nameservice.v1beta1.QueryListRecordsRequest")
proto.RegisterType((*QueryListRecordsRequest_ReferenceInput)(nil), "vulcanize.nameservice.v1beta1.QueryListRecordsRequest.ReferenceInput")
proto.RegisterType((*QueryListRecordsRequest_ValueInput)(nil), "vulcanize.nameservice.v1beta1.QueryListRecordsRequest.ValueInput")
proto.RegisterType((*QueryListRecordsRequest_KeyValueInput)(nil), "vulcanize.nameservice.v1beta1.QueryListRecordsRequest.KeyValueInput")
proto.RegisterType((*QueryListRecordsResponse)(nil), "vulcanize.nameservice.v1beta1.QueryListRecordsResponse")
@ -1324,90 +1412,96 @@ func init() {
}
var fileDescriptor_73d2465766c8f876 = []byte{
// 1327 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4d, 0x6c, 0x1b, 0x45,
0x14, 0xce, 0xc4, 0x4d, 0xda, 0x3c, 0xd3, 0x94, 0x0e, 0x51, 0x9b, 0x6e, 0x5b, 0xa7, 0x6c, 0xff,
0x1c, 0x88, 0x77, 0x63, 0x97, 0xa6, 0x6d, 0x2a, 0x10, 0x71, 0x1a, 0xa2, 0x94, 0x82, 0xc8, 0x82,
0x08, 0xe2, 0x40, 0xb5, 0xb6, 0x07, 0x67, 0x89, 0xbd, 0xe3, 0xee, 0xce, 0x26, 0x75, 0xab, 0x5e,
0x38, 0xf4, 0x86, 0x84, 0xc4, 0x19, 0x04, 0x12, 0xa7, 0x4a, 0xc0, 0xb5, 0x77, 0x2e, 0x11, 0xa7,
0x4a, 0x70, 0xe0, 0x14, 0x50, 0x82, 0xc4, 0xbd, 0x47, 0x4e, 0x68, 0x67, 0x66, 0xd7, 0xbb, 0x89,
0x13, 0xaf, 0x9d, 0x20, 0x71, 0xf2, 0xee, 0xcc, 0xfb, 0xde, 0x7b, 0xdf, 0x7b, 0x6f, 0xde, 0xbc,
0x35, 0x8c, 0xaf, 0x7a, 0xb5, 0xb2, 0x69, 0x5b, 0x0f, 0x88, 0x6e, 0x9b, 0x75, 0xe2, 0x12, 0x67,
0xd5, 0x2a, 0x13, 0x7d, 0x35, 0x5f, 0x22, 0xcc, 0xcc, 0xeb, 0xf7, 0x3c, 0xe2, 0x34, 0xb5, 0x86,
0x43, 0x19, 0xc5, 0x67, 0x43, 0x51, 0x2d, 0x22, 0xaa, 0x49, 0x51, 0x45, 0xdf, 0x5b, 0x53, 0x14,
0xc2, 0xf5, 0x29, 0x67, 0xaa, 0x94, 0x56, 0x6b, 0x44, 0x37, 0x1b, 0x96, 0x6e, 0xda, 0x36, 0x65,
0x26, 0xb3, 0xa8, 0xed, 0xca, 0xdd, 0x57, 0xca, 0xd4, 0xad, 0x53, 0x57, 0x2f, 0x99, 0x2e, 0x11,
0x6e, 0x84, 0xaa, 0x1a, 0x66, 0xd5, 0xb2, 0xb9, 0xb0, 0x94, 0x1d, 0xa9, 0xd2, 0x2a, 0xe5, 0x8f,
0xba, 0xff, 0x24, 0x57, 0x33, 0x51, 0x0d, 0x01, 0xb6, 0x4c, 0x2d, 0x89, 0x52, 0x47, 0x00, 0x2f,
0xfa, 0x7a, 0xdf, 0x33, 0x1d, 0xb3, 0xee, 0x1a, 0xe4, 0x9e, 0x47, 0x5c, 0xa6, 0x7e, 0x00, 0x2f,
0xc5, 0x56, 0xdd, 0x06, 0xb5, 0x5d, 0x82, 0x5f, 0x87, 0xc1, 0x06, 0x5f, 0x19, 0x45, 0xe7, 0x50,
0x36, 0x5d, 0xb8, 0xa8, 0xed, 0x19, 0x0d, 0x4d, 0xc2, 0x25, 0x48, 0xfd, 0x22, 0x05, 0x27, 0xb9,
0xda, 0x3b, 0x96, 0xcb, 0x0c, 0x52, 0xa6, 0x4e, 0x25, 0xb0, 0x88, 0x2b, 0x00, 0x26, 0x63, 0x8e,
0x55, 0xf2, 0x18, 0xf1, 0xd5, 0xa7, 0xb2, 0xe9, 0xc2, 0xad, 0x0e, 0xea, 0x77, 0xd1, 0xa5, 0xbd,
0x4d, 0x9a, 0x1f, 0x9a, 0x35, 0x8f, 0x2c, 0xd8, 0x0d, 0x8f, 0x19, 0x11, 0xbd, 0xf8, 0x45, 0x48,
0x99, 0xb5, 0xda, 0x68, 0xff, 0x39, 0x94, 0x3d, 0x62, 0xf8, 0x8f, 0xf8, 0x2d, 0x80, 0x56, 0x24,
0x47, 0x53, 0x9c, 0xd6, 0x25, 0x4d, 0x04, 0x4d, 0xf3, 0x83, 0xa6, 0x89, 0xec, 0xb7, 0x28, 0x55,
0x89, 0xb4, 0x63, 0x44, 0x90, 0xca, 0x14, 0x40, 0xcb, 0x26, 0x3e, 0x01, 0x83, 0x2e, 0x73, 0x2c,
0xbb, 0xca, 0x03, 0x35, 0x64, 0xc8, 0x37, 0xdf, 0xbe, 0x65, 0x33, 0x6e, 0x3f, 0x65, 0xf8, 0x8f,
0xca, 0x03, 0x38, 0x1a, 0x73, 0xd7, 0x17, 0x59, 0x21, 0x4d, 0x89, 0xf3, 0x1f, 0xf1, 0x12, 0x0c,
0xac, 0xfa, 0xfb, 0x1c, 0x96, 0x2e, 0xcc, 0xf4, 0x18, 0x95, 0x48, 0x48, 0x84, 0x3e, 0xf5, 0x09,
0x82, 0xd1, 0x9d, 0xd2, 0x32, 0xd7, 0x73, 0x70, 0xd8, 0x11, 0x4b, 0x32, 0x1b, 0x9d, 0x92, 0x2d,
0x14, 0x14, 0x0f, 0xad, 0x6f, 0x8c, 0xf5, 0x19, 0x01, 0x16, 0xcf, 0xc7, 0xe2, 0x2b, 0x18, 0x5c,
0xee, 0x18, 0x5f, 0xe1, 0x43, 0x34, 0xc0, 0x6a, 0x16, 0x4e, 0x70, 0x5f, 0xa5, 0x99, 0xe6, 0x42,
0x25, 0x28, 0x9d, 0x61, 0xe8, 0xb7, 0x2a, 0x32, 0x60, 0xfd, 0x56, 0x45, 0xfd, 0x44, 0x56, 0x59,
0x54, 0x52, 0x92, 0x9a, 0x85, 0x41, 0xe1, 0x58, 0xc2, 0x02, 0x8e, 0x71, 0x92, 0x50, 0x95, 0x81,
0x12, 0xd3, 0x5f, 0xa4, 0x76, 0x65, 0x57, 0x6f, 0xb6, 0x15, 0x58, 0x7f, 0xaf, 0x05, 0xa6, 0xfe,
0x80, 0xe0, 0x74, 0x5b, 0xb3, 0xff, 0xd3, 0x7c, 0x5d, 0x00, 0x75, 0x9e, 0xb0, 0x77, 0xcd, 0x3a,
0x79, 0x5f, 0x18, 0x7e, 0x87, 0x56, 0xbc, 0x1a, 0x29, 0x9a, 0x35, 0xd3, 0x2e, 0x07, 0x0c, 0xd5,
0x06, 0x9c, 0xdf, 0x53, 0x4a, 0x92, 0x5b, 0x80, 0x23, 0x25, 0xb1, 0x14, 0xb0, 0xcb, 0x75, 0x60,
0x37, 0x53, 0x2e, 0x53, 0xcf, 0x66, 0x81, 0xa2, 0x10, 0xae, 0xfe, 0x8d, 0x60, 0x38, 0xbe, 0x89,
0xef, 0xc0, 0x0b, 0xa6, 0x58, 0xb9, 0xeb, 0xab, 0x12, 0xc9, 0x2b, 0x8e, 0x3f, 0xdf, 0x18, 0xbb,
0xf8, 0x99, 0x4b, 0xed, 0x69, 0x55, 0xee, 0xfa, 0x6e, 0xaa, 0xe7, 0x9a, 0x66, 0xbd, 0x16, 0x5f,
0x32, 0xd2, 0x91, 0x37, 0xfc, 0x18, 0xc1, 0x61, 0x69, 0x6d, 0x34, 0xc5, 0x7d, 0x3d, 0x15, 0x8b,
0x5f, 0xe0, 0xe1, 0x2c, 0xb5, 0xec, 0xe2, 0xa2, 0x1f, 0xfd, 0xe7, 0x1b, 0x63, 0x67, 0x85, 0x21,
0x89, 0x0b, 0x8c, 0x04, 0xaf, 0x4f, 0xfe, 0x18, 0xcb, 0x56, 0x2d, 0xb6, 0xec, 0x95, 0xb4, 0x32,
0xad, 0xeb, 0xb2, 0xa5, 0x8b, 0x9f, 0x9c, 0x5b, 0x59, 0xd1, 0x59, 0xb3, 0x41, 0x5c, 0xae, 0xd1,
0x35, 0x02, 0xe3, 0x2a, 0x91, 0x05, 0xe3, 0x9f, 0x6e, 0xdf, 0xb3, 0x6d, 0x1d, 0x37, 0x5e, 0x98,
0x68, 0x3f, 0x85, 0x79, 0xa6, 0xbd, 0x1d, 0x99, 0xbc, 0x5b, 0x30, 0xc0, 0x33, 0x24, 0x33, 0x97,
0xed, 0x90, 0x39, 0x5f, 0xc5, 0x9c, 0xcd, 0x9c, 0xa6, 0x2c, 0x4d, 0x01, 0x3e, 0xb8, 0xc2, 0xbc,
0x0c, 0xc7, 0xb9, 0xbb, 0x4b, 0xcb, 0xd4, 0x0a, 0x83, 0x81, 0xe1, 0x50, 0x2b, 0xf5, 0x06, 0x7f,
0x56, 0xbf, 0x46, 0xf2, 0x6e, 0x94, 0x92, 0x92, 0xce, 0x63, 0x04, 0xc3, 0xfe, 0xfe, 0x5d, 0xd3,
0x63, 0xcb, 0xd4, 0xb1, 0x58, 0x53, 0x06, 0x6f, 0x22, 0x01, 0xb1, 0x99, 0x00, 0x53, 0xcc, 0xcb,
0xcc, 0x8f, 0x8b, 0xcc, 0xdb, 0xd1, 0xcd, 0x20, 0xff, 0xf1, 0x45, 0xe3, 0x68, 0xfc, 0x5d, 0x85,
0x61, 0x11, 0x77, 0x4a, 0x57, 0xbc, 0xc6, 0x92, 0x63, 0xfb, 0x77, 0xc7, 0x9a, 0x63, 0x07, 0x77,
0xc7, 0x9a, 0x63, 0xab, 0x4b, 0xb2, 0x6b, 0x86, 0x32, 0x91, 0xbb, 0xbc, 0xc5, 0x38, 0x5d, 0x18,
0x4f, 0xe0, 0xbb, 0xc8, 0xab, 0x0c, 0xce, 0x79, 0x38, 0x26, 0xbb, 0x91, 0x4b, 0x6b, 0xab, 0xa4,
0xbd, 0xf5, 0x8f, 0xc2, 0x4e, 0x1c, 0x08, 0x45, 0x47, 0x89, 0x1e, 0x3a, 0x71, 0xd8, 0x83, 0xcb,
0x70, 0x8a, 0x6b, 0x9e, 0x27, 0xf2, 0xe2, 0x9a, 0xbb, 0xdf, 0xb0, 0x9c, 0xe6, 0xa2, 0x47, 0x3c,
0x72, 0x60, 0x95, 0xfd, 0x14, 0xc1, 0xcb, 0xbb, 0x5a, 0x09, 0x99, 0xdc, 0xde, 0xde, 0x78, 0x27,
0x3b, 0x50, 0x89, 0x29, 0xe1, 0xac, 0x0e, 0xbe, 0xfb, 0xde, 0x80, 0xe3, 0x3b, 0xcc, 0xec, 0xb8,
0x9a, 0x46, 0x5a, 0x83, 0x45, 0x2a, 0x3b, 0x14, 0x4c, 0x05, 0x9f, 0xca, 0xe3, 0x3c, 0x4f, 0x58,
0x58, 0x6b, 0xff, 0x45, 0x74, 0x7f, 0x46, 0x70, 0x61, 0x2f, 0x43, 0x61, 0x80, 0x0d, 0x48, 0x07,
0x47, 0xcd, 0x22, 0xbd, 0x07, 0x39, 0xaa, 0xe4, 0xc0, 0x02, 0x5d, 0xf8, 0xe7, 0x18, 0x0c, 0x70,
0x16, 0xf8, 0x1b, 0x04, 0x83, 0x62, 0xe0, 0xc5, 0xf9, 0x24, 0x23, 0x5a, 0x6c, 0xe2, 0x56, 0x0a,
0xdd, 0x40, 0x84, 0x1f, 0x6a, 0xee, 0xf3, 0x5f, 0xff, 0xfa, 0xaa, 0xff, 0x32, 0xbe, 0xd8, 0xe1,
0xab, 0x43, 0x8c, 0xdf, 0xf8, 0x47, 0x04, 0xe9, 0xc8, 0xa4, 0x87, 0xa7, 0x7a, 0x1b, 0x24, 0x95,
0x6b, 0x5d, 0xe3, 0xa4, 0xbf, 0x1a, 0xf7, 0x37, 0x8b, 0x2f, 0x75, 0xf0, 0x37, 0x38, 0x0d, 0x3f,
0x21, 0x18, 0x0a, 0x8f, 0x1e, 0xbe, 0x9a, 0xc4, 0xec, 0x8e, 0xe9, 0x50, 0x99, 0xea, 0x16, 0x26,
0x9d, 0xbd, 0xc2, 0x9d, 0xcd, 0xe1, 0x57, 0x93, 0x39, 0xab, 0x3f, 0xb4, 0x2a, 0x8f, 0xf0, 0x2f,
0x08, 0x8e, 0x87, 0x1e, 0x07, 0x23, 0x1a, 0xbe, 0xd1, 0x8d, 0x0b, 0xb1, 0x69, 0x52, 0x99, 0xee,
0x05, 0x2a, 0x19, 0xbc, 0xc1, 0x19, 0x5c, 0xc7, 0x53, 0xc9, 0x18, 0xe4, 0x4a, 0xcd, 0x5c, 0x89,
0xda, 0x95, 0x9c, 0x55, 0x11, 0x64, 0x7e, 0x43, 0x70, 0x7a, 0x8f, 0xe1, 0x0c, 0x77, 0xfa, 0x10,
0xe9, 0x3c, 0xfe, 0x29, 0xc5, 0xfd, 0xa8, 0xe8, 0xb2, 0xaa, 0xe4, 0x58, 0x84, 0x9f, 0x22, 0x38,
0xb6, 0x6d, 0x54, 0xc1, 0xd3, 0x49, 0x4b, 0x7a, 0xe7, 0x1c, 0xa5, 0xdc, 0xec, 0x09, 0x2b, 0x9d,
0x9f, 0xe0, 0xce, 0x5f, 0xc2, 0x17, 0x92, 0xfc, 0x71, 0x80, 0xbf, 0x43, 0x30, 0xc0, 0x87, 0x11,
0x3c, 0x99, 0xc4, 0x68, 0x74, 0xc2, 0x51, 0xf2, 0x5d, 0x20, 0xba, 0x3c, 0x02, 0x6b, 0x3e, 0x4a,
0x7f, 0xe8, 0x6f, 0x3d, 0xc2, 0xdf, 0x22, 0x18, 0x6a, 0x4d, 0x24, 0xb9, 0x44, 0xc1, 0x09, 0xc4,
0x95, 0xab, 0x5d, 0x89, 0x77, 0xdd, 0x08, 0x6b, 0x1c, 0x89, 0xbf, 0x47, 0x00, 0x91, 0xb9, 0x45,
0x4b, 0x76, 0xc6, 0x02, 0xf9, 0xa4, 0x1d, 0x65, 0xfb, 0xc8, 0xd3, 0x45, 0xfb, 0xe3, 0x50, 0xbc,
0x8e, 0x60, 0xa4, 0xed, 0x7c, 0x73, 0x3d, 0x89, 0x03, 0xed, 0x90, 0xca, 0x9b, 0xbd, 0x22, 0x43,
0x12, 0xaf, 0x71, 0x12, 0x1a, 0x9e, 0x48, 0xd4, 0x54, 0x72, 0x84, 0xab, 0xf0, 0x5b, 0xc9, 0xc9,
0xdd, 0xe6, 0x89, 0x9b, 0x09, 0x7d, 0x6a, 0x07, 0x56, 0x66, 0xf7, 0x01, 0x0e, 0x39, 0x5d, 0xe3,
0x9c, 0xf2, 0x58, 0xef, 0xc0, 0x29, 0x1c, 0xf8, 0x25, 0xad, 0xe2, 0xed, 0xf5, 0xcd, 0x0c, 0x7a,
0xb6, 0x99, 0x41, 0x7f, 0x6e, 0x66, 0xd0, 0x97, 0x5b, 0x99, 0xbe, 0x67, 0x5b, 0x99, 0xbe, 0xdf,
0xb7, 0x32, 0x7d, 0x1f, 0x4f, 0x46, 0x3e, 0xd7, 0xd8, 0xb2, 0xe9, 0xb8, 0x96, 0xab, 0x13, 0xb6,
0x4c, 0x9c, 0xba, 0x65, 0x33, 0xfd, 0x7e, 0x4c, 0x3d, 0xff, 0x78, 0x2b, 0x0d, 0xf2, 0xff, 0xe3,
0xae, 0xfc, 0x1b, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x7d, 0xf0, 0x84, 0x8c, 0x14, 0x00, 0x00,
// 1414 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0x4b, 0x6c, 0x1b, 0xc5,
0x1b, 0xcf, 0x24, 0xb1, 0xd3, 0x7c, 0xf9, 0x37, 0xfd, 0x77, 0x88, 0x5a, 0x77, 0xdb, 0x3a, 0x61,
0xfb, 0x72, 0xa0, 0xde, 0x6d, 0x52, 0xfa, 0x16, 0x88, 0xba, 0x0d, 0x51, 0x4b, 0x41, 0x74, 0x41,
0x04, 0x38, 0x50, 0xad, 0xed, 0xa9, 0xb3, 0x74, 0x3d, 0xe3, 0xee, 0xce, 0xa6, 0x75, 0xab, 0x5e,
0x38, 0xf4, 0x8c, 0xc4, 0x19, 0x04, 0x12, 0xa7, 0x4a, 0xc0, 0x85, 0x43, 0xc5, 0x95, 0x4b, 0xc5,
0xa9, 0x12, 0x1c, 0x38, 0x15, 0xd4, 0x22, 0x71, 0xef, 0x91, 0x13, 0xda, 0x99, 0xd9, 0xf5, 0x6e,
0xe2, 0xc4, 0x6b, 0x27, 0x48, 0x9c, 0x3c, 0x3b, 0xfb, 0x3d, 0x7e, 0xbf, 0xef, 0x31, 0xfb, 0x8d,
0x61, 0x76, 0x25, 0x70, 0x6b, 0x36, 0x75, 0xee, 0x10, 0x93, 0xda, 0x4d, 0xe2, 0x13, 0x6f, 0xc5,
0xa9, 0x11, 0x73, 0x65, 0xae, 0x4a, 0xb8, 0x3d, 0x67, 0xde, 0x0c, 0x88, 0xd7, 0x36, 0x5a, 0x1e,
0xe3, 0x0c, 0xef, 0x8f, 0x45, 0x8d, 0x84, 0xa8, 0xa1, 0x44, 0x35, 0x73, 0x63, 0x4b, 0x49, 0x15,
0x61, 0x4f, 0xdb, 0xd7, 0x60, 0xac, 0xe1, 0x12, 0xd3, 0x6e, 0x39, 0xa6, 0x4d, 0x29, 0xe3, 0x36,
0x77, 0x18, 0xf5, 0xd5, 0xdb, 0x97, 0x6a, 0xcc, 0x6f, 0x32, 0xdf, 0xac, 0xda, 0x3e, 0x91, 0x30,
0x62, 0x53, 0x2d, 0xbb, 0xe1, 0x50, 0x21, 0xac, 0x64, 0xa7, 0x1a, 0xac, 0xc1, 0xc4, 0xd2, 0x0c,
0x57, 0x6a, 0xb7, 0x98, 0xb4, 0x10, 0xe9, 0xd6, 0x98, 0xa3, 0xb4, 0xf4, 0x29, 0xc0, 0x57, 0x43,
0xbb, 0xef, 0xd8, 0x9e, 0xdd, 0xf4, 0x2d, 0x72, 0x33, 0x20, 0x3e, 0xd7, 0xdf, 0x83, 0x17, 0x52,
0xbb, 0x7e, 0x8b, 0x51, 0x9f, 0xe0, 0x57, 0x21, 0xdf, 0x12, 0x3b, 0x05, 0x34, 0x83, 0x4a, 0x13,
0xf3, 0x87, 0x8c, 0x0d, 0xa3, 0x61, 0x28, 0x75, 0xa5, 0xa4, 0xff, 0x90, 0x83, 0xdd, 0xc2, 0xec,
0x15, 0xc7, 0xe7, 0x16, 0xa9, 0x31, 0xaf, 0x1e, 0x79, 0xc4, 0x75, 0x00, 0x9b, 0x73, 0xcf, 0xa9,
0x06, 0x9c, 0x84, 0xe6, 0x47, 0x4a, 0x13, 0xf3, 0x17, 0x7b, 0x98, 0x5f, 0xc7, 0x96, 0xf1, 0x26,
0x69, 0xbf, 0x6f, 0xbb, 0x01, 0xb9, 0x44, 0x5b, 0x01, 0xb7, 0x12, 0x76, 0xf1, 0xff, 0x61, 0xc4,
0x76, 0xdd, 0xc2, 0xf0, 0x0c, 0x2a, 0x6d, 0xb3, 0xc2, 0x25, 0x7e, 0x03, 0xa0, 0x13, 0xc9, 0xc2,
0x88, 0xa0, 0x75, 0xd8, 0x90, 0x41, 0x33, 0xc2, 0xa0, 0x19, 0x32, 0xfb, 0x1d, 0x4a, 0x0d, 0xa2,
0xfc, 0x58, 0x09, 0x4d, 0x6d, 0x06, 0x26, 0x2d, 0x72, 0x9d, 0x78, 0x84, 0xd6, 0xa4, 0x5f, 0x3c,
0x09, 0xc3, 0x4e, 0x5d, 0x04, 0x6a, 0xdc, 0x1a, 0x76, 0xea, 0xda, 0x8f, 0xc3, 0x00, 0x1d, 0x58,
0x18, 0xc3, 0x28, 0x6f, 0xb7, 0x88, 0x12, 0x10, 0x6b, 0xbc, 0x0b, 0xf2, 0x3e, 0xf7, 0x1c, 0xda,
0x10, 0x08, 0xc7, 0x2d, 0xf5, 0x14, 0xc2, 0x76, 0x28, 0x17, 0xe8, 0x46, 0xac, 0x70, 0x89, 0xa7,
0x20, 0x77, 0xdd, 0x65, 0x36, 0x2f, 0x8c, 0xce, 0xa0, 0x12, 0xb2, 0xe4, 0x03, 0x2e, 0xc0, 0x58,
0x95, 0x31, 0x97, 0xd8, 0xb4, 0x90, 0x13, 0x14, 0xa3, 0x47, 0x5c, 0x83, 0x71, 0x2f, 0x82, 0x57,
0xc8, 0x0b, 0x96, 0x0b, 0x03, 0x46, 0x37, 0x4d, 0xd3, 0xea, 0xd8, 0xc5, 0x1f, 0x42, 0x7e, 0x25,
0x24, 0xe8, 0x17, 0xc6, 0x44, 0xfe, 0xce, 0x0f, 0xe8, 0x21, 0x91, 0x3c, 0x65, 0x50, 0xbb, 0x03,
0xdb, 0x53, 0x59, 0x0d, 0x43, 0x72, 0x83, 0xb4, 0x55, 0xf4, 0xc2, 0x25, 0x5e, 0x82, 0x9c, 0x10,
0x16, 0xb1, 0xdb, 0x12, 0xe7, 0xd2, 0x9e, 0xfe, 0x00, 0x41, 0x61, 0xad, 0xb4, 0x6a, 0x89, 0x05,
0x18, 0xf3, 0xe4, 0x96, 0x2a, 0xda, 0x5e, 0x3d, 0x21, 0x0d, 0x54, 0x46, 0x1f, 0x3d, 0x99, 0x1e,
0xb2, 0x22, 0x5d, 0xbc, 0x98, 0x2a, 0x43, 0xc9, 0xe0, 0x48, 0xcf, 0x32, 0x94, 0x18, 0x92, 0x75,
0xa8, 0x97, 0x60, 0x97, 0xc0, 0xaa, 0xdc, 0xb4, 0x2f, 0xd5, 0xa3, 0x0e, 0x5b, 0x55, 0x8f, 0xfa,
0xc7, 0xaa, 0x19, 0x93, 0x92, 0x8a, 0xd4, 0x05, 0xc8, 0x4b, 0x60, 0x19, 0xfb, 0x3c, 0xc5, 0x49,
0xa9, 0xea, 0x1c, 0xb4, 0x94, 0xfd, 0x0a, 0xa3, 0xf5, 0x75, 0xd1, 0xac, 0xea, 0xc3, 0xe1, 0x41,
0xfb, 0x50, 0xff, 0x16, 0xc1, 0xde, 0xae, 0x6e, 0xff, 0xa3, 0xf9, 0x3a, 0x08, 0xfa, 0x22, 0xe1,
0x6f, 0xdb, 0x4d, 0xf2, 0xae, 0x74, 0xfc, 0x16, 0xab, 0x07, 0x2e, 0xa9, 0xd8, 0xae, 0x4d, 0x6b,
0x11, 0x43, 0xbd, 0x05, 0x07, 0x36, 0x94, 0x52, 0xe4, 0x2e, 0xc1, 0xb6, 0xaa, 0xdc, 0x8a, 0xd8,
0x95, 0x7b, 0xb0, 0x3b, 0x5f, 0xab, 0xb1, 0x80, 0xf2, 0xc8, 0x50, 0xac, 0xae, 0xff, 0x85, 0x60,
0x32, 0xfd, 0x12, 0x5f, 0x81, 0xff, 0xd9, 0x72, 0xe7, 0x5a, 0x68, 0x4a, 0x26, 0xaf, 0x32, 0xfb,
0xfc, 0xc9, 0xf4, 0xa1, 0x4f, 0x7c, 0x46, 0xcf, 0xea, 0xea, 0x6d, 0x08, 0x53, 0x9f, 0x69, 0xdb,
0x4d, 0x37, 0xbd, 0x65, 0x4d, 0x24, 0x9e, 0xf0, 0x7d, 0x04, 0x63, 0xca, 0x5b, 0x61, 0x44, 0x60,
0xdd, 0x93, 0x8a, 0x5f, 0x84, 0xf0, 0x02, 0x73, 0x68, 0xe5, 0x6a, 0x18, 0xfd, 0xe7, 0x4f, 0xa6,
0xf7, 0x4b, 0x47, 0x4a, 0x2f, 0x72, 0x12, 0x3d, 0x3e, 0xf8, 0x7d, 0xba, 0xd4, 0x70, 0xf8, 0x72,
0x50, 0x35, 0x6a, 0xac, 0x69, 0xaa, 0x2f, 0x9f, 0xfc, 0x29, 0xfb, 0xf5, 0x1b, 0x66, 0x78, 0xc8,
0xfa, 0xc2, 0xa2, 0x6f, 0x45, 0xce, 0x75, 0xa2, 0x0a, 0x26, 0xec, 0xee, 0x10, 0xd9, 0xaa, 0x0f,
0x53, 0xba, 0x30, 0xd1, 0x66, 0x0a, 0x73, 0x5f, 0x77, 0x3f, 0x2a, 0x79, 0x17, 0x21, 0x27, 0x32,
0xa4, 0x32, 0x57, 0xea, 0x91, 0xb9, 0xd0, 0xc4, 0x02, 0xe5, 0x5e, 0x5b, 0x95, 0xa6, 0x54, 0xde,
0xba, 0xc2, 0x3c, 0x02, 0x3b, 0x05, 0xdc, 0xa5, 0x65, 0xe6, 0xc4, 0xc1, 0xc0, 0x30, 0xda, 0x49,
0xbd, 0x25, 0xd6, 0xfa, 0x17, 0x48, 0x8d, 0x10, 0x4a, 0x52, 0xd1, 0xb9, 0x8f, 0x60, 0x32, 0x7c,
0x7f, 0xcd, 0x0e, 0xf8, 0x32, 0xf3, 0x1c, 0xde, 0x56, 0xc1, 0x3b, 0x9a, 0x81, 0xd8, 0xf9, 0x48,
0xa7, 0x32, 0xa7, 0x32, 0x3f, 0x2b, 0x33, 0x4f, 0x93, 0x2f, 0xa3, 0xfc, 0xa7, 0x37, 0xad, 0xed,
0xe9, 0x67, 0x1d, 0x26, 0x65, 0xdc, 0x19, 0xbb, 0x11, 0xb4, 0x96, 0x3c, 0x1a, 0x7e, 0x3b, 0x6e,
0x79, 0x34, 0xfa, 0x76, 0xdc, 0xf2, 0xa8, 0xbe, 0xa4, 0x4e, 0xcd, 0x58, 0x26, 0x31, 0xf2, 0x74,
0x18, 0x4f, 0xcc, 0xcf, 0x66, 0xc0, 0x2e, 0xf3, 0xaa, 0x82, 0x73, 0x00, 0x76, 0xa8, 0xd3, 0xc8,
0x67, 0xee, 0x0a, 0xe9, 0xee, 0xfd, 0x83, 0xf8, 0x24, 0x8e, 0x84, 0x92, 0x13, 0xd7, 0x00, 0x27,
0x71, 0x7c, 0x06, 0xd7, 0x60, 0x8f, 0xb0, 0xbc, 0x48, 0xd4, 0x87, 0x6b, 0xe1, 0x76, 0xcb, 0xf1,
0xda, 0x57, 0x03, 0x12, 0x90, 0x2d, 0xab, 0xec, 0x87, 0x08, 0x5e, 0x5c, 0xd7, 0x4b, 0xcc, 0xe4,
0xf2, 0xea, 0x83, 0xf7, 0x58, 0x0f, 0x2a, 0x29, 0x23, 0x82, 0xd5, 0xd6, 0x9f, 0xbe, 0x67, 0x60,
0xe7, 0x1a, 0x37, 0x6b, 0x3e, 0x4d, 0x53, 0x9d, 0xc1, 0x62, 0xa4, 0x34, 0x1e, 0x4d, 0x05, 0xd7,
0x55, 0x3b, 0x2f, 0x12, 0x1e, 0xd7, 0xda, 0xbf, 0x11, 0xdd, 0x9f, 0x10, 0x1c, 0xdc, 0xc8, 0x51,
0x1c, 0x60, 0x0b, 0x26, 0xa2, 0x56, 0x73, 0xc8, 0xe0, 0x41, 0x4e, 0x1a, 0xd9, 0xb2, 0x40, 0xcf,
0xff, 0xbd, 0x03, 0x72, 0x82, 0x05, 0xfe, 0x12, 0x41, 0x5e, 0xde, 0x0b, 0xf0, 0x5c, 0x96, 0x11,
0x2d, 0x75, 0x31, 0xd1, 0xe6, 0xfb, 0x51, 0x91, 0x38, 0xf4, 0xf2, 0xa7, 0xbf, 0xfc, 0xf9, 0xf9,
0xf0, 0x11, 0x7c, 0xa8, 0xc7, 0xe5, 0x4c, 0xde, 0x52, 0xf0, 0x77, 0x08, 0x26, 0x12, 0x93, 0x1e,
0x3e, 0x39, 0xd8, 0x20, 0xa9, 0x9d, 0xea, 0x5b, 0x4f, 0xe1, 0x35, 0x04, 0xde, 0x12, 0x3e, 0xdc,
0x03, 0x6f, 0xd4, 0x0d, 0xdf, 0x23, 0x18, 0x8f, 0x5b, 0x0f, 0x9f, 0xc8, 0xe2, 0x76, 0xcd, 0x74,
0xa8, 0x9d, 0xec, 0x57, 0x4d, 0x81, 0x3d, 0x2e, 0xc0, 0x96, 0xf1, 0xcb, 0xd9, 0xc0, 0x9a, 0x77,
0x9d, 0xfa, 0x3d, 0xfc, 0x33, 0x82, 0x9d, 0x31, 0xe2, 0x68, 0x44, 0xc3, 0x67, 0xfa, 0x81, 0x90,
0x9a, 0x26, 0xb5, 0xb3, 0x83, 0xa8, 0x2a, 0x06, 0xaf, 0x09, 0x06, 0xa7, 0xf1, 0xc9, 0x6c, 0x0c,
0xca, 0xd5, 0x76, 0xb9, 0xca, 0x68, 0xbd, 0xec, 0xd4, 0x25, 0x99, 0x5f, 0x11, 0xec, 0xdd, 0x60,
0x38, 0xc3, 0xbd, 0x2e, 0x22, 0xbd, 0xc7, 0x3f, 0xad, 0xb2, 0x19, 0x13, 0x7d, 0x56, 0x95, 0x1a,
0x8b, 0xf0, 0x43, 0x04, 0x3b, 0x56, 0x8d, 0x2a, 0xf8, 0x6c, 0xd6, 0x92, 0x5e, 0x3b, 0x47, 0x69,
0xe7, 0x06, 0xd2, 0x55, 0xe0, 0x8f, 0x0a, 0xf0, 0x87, 0xf1, 0xc1, 0x2c, 0xff, 0xaf, 0xe0, 0xaf,
0x11, 0xe4, 0xc4, 0x30, 0x82, 0x8f, 0x65, 0x71, 0x9a, 0x9c, 0x70, 0xb4, 0xb9, 0x3e, 0x34, 0xfa,
0x6c, 0x81, 0x5b, 0xa1, 0x96, 0x79, 0x37, 0x7c, 0x75, 0x0f, 0x7f, 0x85, 0x60, 0xbc, 0x33, 0x91,
0x94, 0x33, 0x05, 0x27, 0x12, 0xd7, 0x4e, 0xf4, 0x25, 0xde, 0xf7, 0x41, 0xe8, 0x0a, 0x4d, 0xfc,
0x0d, 0x02, 0x48, 0xcc, 0x2d, 0x46, 0xb6, 0x1e, 0x8b, 0xe4, 0xb3, 0x9e, 0x28, 0xab, 0x47, 0x9e,
0x3e, 0x8e, 0x3f, 0xa1, 0x8a, 0x1f, 0x21, 0x98, 0xea, 0x3a, 0xdf, 0x9c, 0xce, 0x02, 0xa0, 0x9b,
0xa6, 0xf6, 0xfa, 0xa0, 0x9a, 0x31, 0x89, 0x57, 0x04, 0x09, 0x03, 0x1f, 0xcd, 0x74, 0xa8, 0x94,
0x89, 0x30, 0x11, 0x1e, 0x25, 0xbb, 0xd7, 0x9b, 0x27, 0xce, 0x65, 0xc4, 0xd4, 0x4d, 0x59, 0xbb,
0xb0, 0x09, 0xe5, 0x98, 0xd3, 0x29, 0xc1, 0x69, 0x0e, 0x9b, 0x3d, 0x38, 0xc5, 0x03, 0xbf, 0xa2,
0x55, 0xb9, 0xfc, 0xe8, 0x69, 0x11, 0x3d, 0x7e, 0x5a, 0x44, 0x7f, 0x3c, 0x2d, 0xa2, 0xcf, 0x9e,
0x15, 0x87, 0x1e, 0x3f, 0x2b, 0x0e, 0xfd, 0xf6, 0xac, 0x38, 0xf4, 0xd1, 0xb1, 0xc4, 0x75, 0x8d,
0x2f, 0xdb, 0x9e, 0xef, 0xf8, 0x26, 0xe1, 0xcb, 0xc4, 0x6b, 0x3a, 0x94, 0x9b, 0xb7, 0x53, 0xe6,
0xc5, 0xe5, 0xad, 0x9a, 0x17, 0x7f, 0x5b, 0x1e, 0xff, 0x27, 0x00, 0x00, 0xff, 0xff, 0x94, 0xc7,
0x31, 0xc3, 0xb3, 0x15, 0x00, 0x00,
}
// Reference imports to suppress errors if they are not otherwise used.
@ -1989,6 +2083,36 @@ func (m *QueryListRecordsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error)
return len(dAtA) - i, nil
}
func (m *QueryListRecordsRequest_ReferenceInput) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *QueryListRecordsRequest_ReferenceInput) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *QueryListRecordsRequest_ReferenceInput) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.Id) > 0 {
i -= len(m.Id)
copy(dAtA[i:], m.Id)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Id)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *QueryListRecordsRequest_ValueInput) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -2009,16 +2133,65 @@ func (m *QueryListRecordsRequest_ValueInput) MarshalToSizedBuffer(dAtA []byte) (
_ = i
var l int
_ = l
if len(m.Values) > 0 {
for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.Values[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x3a
}
}
if m.Reference != nil {
{
size, err := m.Reference.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintQuery(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x32
}
if m.Boolean {
i--
if m.Boolean {
dAtA[i] = 1
} else {
dAtA[i] = 0
}
i--
dAtA[i] = 0x28
}
if m.Float != 0 {
i -= 8
encoding_binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.Float))))
i--
dAtA[i] = 0x21
}
if m.Int != 0 {
i = encodeVarintQuery(dAtA, i, uint64(m.Int))
i--
dAtA[i] = 0x10
dAtA[i] = 0x18
}
if len(m.String_) > 0 {
i -= len(m.String_)
copy(dAtA[i:], m.String_)
i = encodeVarintQuery(dAtA, i, uint64(len(m.String_)))
i--
dAtA[i] = 0x12
}
if len(m.Type) > 0 {
i -= len(m.Type)
copy(dAtA[i:], m.Type)
i = encodeVarintQuery(dAtA, i, uint64(len(m.Type)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
@ -2912,12 +3085,29 @@ func (m *QueryListRecordsRequest) Size() (n int) {
return n
}
func (m *QueryListRecordsRequest_ReferenceInput) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Id)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
return n
}
func (m *QueryListRecordsRequest_ValueInput) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Type)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
}
l = len(m.String_)
if l > 0 {
n += 1 + l + sovQuery(uint64(l))
@ -2925,6 +3115,22 @@ func (m *QueryListRecordsRequest_ValueInput) Size() (n int) {
if m.Int != 0 {
n += 1 + sovQuery(uint64(m.Int))
}
if m.Float != 0 {
n += 9
}
if m.Boolean {
n += 2
}
if m.Reference != nil {
l = m.Reference.Size()
n += 1 + l + sovQuery(uint64(l))
}
if len(m.Values) > 0 {
for _, e := range m.Values {
l = e.Size()
n += 1 + l + sovQuery(uint64(l))
}
}
return n
}
@ -3540,6 +3746,88 @@ func (m *QueryListRecordsRequest) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *QueryListRecordsRequest_ReferenceInput) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: ReferenceInput: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: ReferenceInput: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Id = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthQuery
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *QueryListRecordsRequest_ValueInput) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
@ -3570,6 +3858,38 @@ func (m *QueryListRecordsRequest_ValueInput) Unmarshal(dAtA []byte) error {
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Type = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field String_", wireType)
}
@ -3601,7 +3921,7 @@ func (m *QueryListRecordsRequest_ValueInput) Unmarshal(dAtA []byte) error {
}
m.String_ = string(dAtA[iNdEx:postIndex])
iNdEx = postIndex
case 2:
case 3:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Int", wireType)
}
@ -3620,6 +3940,107 @@ func (m *QueryListRecordsRequest_ValueInput) Unmarshal(dAtA []byte) error {
break
}
}
case 4:
if wireType != 1 {
return fmt.Errorf("proto: wrong wireType = %d for field Float", wireType)
}
var v uint64
if (iNdEx + 8) > l {
return io.ErrUnexpectedEOF
}
v = uint64(encoding_binary.LittleEndian.Uint64(dAtA[iNdEx:]))
iNdEx += 8
m.Float = float64(math.Float64frombits(v))
case 5:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field Boolean", wireType)
}
var v int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
v |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
m.Boolean = bool(v != 0)
case 6:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Reference", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.Reference == nil {
m.Reference = &QueryListRecordsRequest_ReferenceInput{}
}
if err := m.Reference.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 7:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowQuery
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthQuery
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthQuery
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Values = append(m.Values, &QueryListRecordsRequest_ValueInput{})
if err := m.Values[len(m.Values)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipQuery(dAtA[iNdEx:])