github.com/matrixorigin/matrixone@v0.7.0/pkg/pb/ctl/ctl.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: ctl.proto

package ctl

import (
	fmt "fmt"
	io "io"
	math "math"
	math_bits "math/bits"

	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

// CmdMethod debug command method
type CmdMethod int32

const (
	// Ping ping the service.
	CmdMethod_Ping CmdMethod = 0
	// Flush is to force flush the table data.
	// parameter should be "DbName.TableName"
	CmdMethod_Flush CmdMethod = 1
	// Task disable or enable task framework
	CmdMethod_Task CmdMethod = 2
	// Checkpoint is to force incremental checkpoint.
	CmdMethod_Checkpoint CmdMethod = 3
	// UseSnapshot use a spec snapshot timestamp, and all txn will use this ts as snapshot timestamp
	CmdMethod_UseSnapshot CmdMethod = 4
	// GetSnapshot get current snapshot timestamp
	CmdMethod_GetSnapshot CmdMethod = 5
	// ForceGC forcing a GC to free memory
	CmdMethod_ForceGC CmdMethod = 6
	// Inspect DN info
	CmdMethod_Inspect CmdMethod = 7
)

var CmdMethod_name = map[int32]string{
	0: "Ping",
	1: "Flush",
	2: "Task",
	3: "Checkpoint",
	4: "UseSnapshot",
	5: "GetSnapshot",
	6: "ForceGC",
	7: "Inspect",
}

var CmdMethod_value = map[string]int32{
	"Ping":        0,
	"Flush":       1,
	"Task":        2,
	"Checkpoint":  3,
	"UseSnapshot": 4,
	"GetSnapshot": 5,
	"ForceGC":     6,
	"Inspect":     7,
}

func (x CmdMethod) String() string {
	return proto.EnumName(CmdMethod_name, int32(x))
}

func (CmdMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0646114e50303026, []int{0}
}

// DNPingRequest ping request
type DNPingRequest struct {
	Parameter            string   `protobuf:"bytes,1,opt,name=parameter,proto3" json:"parameter,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DNPingRequest) Reset()         { *m = DNPingRequest{} }
func (m *DNPingRequest) String() string { return proto.CompactTextString(m) }
func (*DNPingRequest) ProtoMessage()    {}
func (*DNPingRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_0646114e50303026, []int{0}
}
func (m *DNPingRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DNPingRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DNPingRequest.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 *DNPingRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DNPingRequest.Merge(m, src)
}
func (m *DNPingRequest) XXX_Size() int {
	return m.Size()
}
func (m *DNPingRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DNPingRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DNPingRequest proto.InternalMessageInfo

func (m *DNPingRequest) GetParameter() string {
	if m != nil {
		return m.Parameter
	}
	return ""
}

// DNPingResponse ping response
type DNPingResponse struct {
	StoreID              string   `protobuf:"bytes,1,opt,name=storeID,proto3" json:"storeID,omitempty"`
	ServiceAddress       string   `protobuf:"bytes,2,opt,name=serviceAddress,proto3" json:"serviceAddress,omitempty"`
	ShardID              uint64   `protobuf:"varint,3,opt,name=shardID,proto3" json:"shardID,omitempty"`
	ReplicaID            uint64   `protobuf:"varint,4,opt,name=replicaID,proto3" json:"replicaID,omitempty"`
	LogShardID           uint64   `protobuf:"varint,5,opt,name=logShardID,proto3" json:"logShardID,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DNPingResponse) Reset()         { *m = DNPingResponse{} }
func (m *DNPingResponse) String() string { return proto.CompactTextString(m) }
func (*DNPingResponse) ProtoMessage()    {}
func (*DNPingResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0646114e50303026, []int{1}
}
func (m *DNPingResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DNPingResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DNPingResponse.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 *DNPingResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DNPingResponse.Merge(m, src)
}
func (m *DNPingResponse) XXX_Size() int {
	return m.Size()
}
func (m *DNPingResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DNPingResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DNPingResponse proto.InternalMessageInfo

func (m *DNPingResponse) GetStoreID() string {
	if m != nil {
		return m.StoreID
	}
	return ""
}

func (m *DNPingResponse) GetServiceAddress() string {
	if m != nil {
		return m.ServiceAddress
	}
	return ""
}

func (m *DNPingResponse) GetShardID() uint64 {
	if m != nil {
		return m.ShardID
	}
	return 0
}

func (m *DNPingResponse) GetReplicaID() uint64 {
	if m != nil {
		return m.ReplicaID
	}
	return 0
}

func (m *DNPingResponse) GetLogShardID() uint64 {
	if m != nil {
		return m.LogShardID
	}
	return 0
}

// DNStringResponse string type response
type DNStringResponse struct {
	ReturnStr            string   `protobuf:"bytes,1,opt,name=returnStr,proto3" json:"returnStr,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DNStringResponse) Reset()         { *m = DNStringResponse{} }
func (m *DNStringResponse) String() string { return proto.CompactTextString(m) }
func (*DNStringResponse) ProtoMessage()    {}
func (*DNStringResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_0646114e50303026, []int{2}
}
func (m *DNStringResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DNStringResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DNStringResponse.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 *DNStringResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DNStringResponse.Merge(m, src)
}
func (m *DNStringResponse) XXX_Size() int {
	return m.Size()
}
func (m *DNStringResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DNStringResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DNStringResponse proto.InternalMessageInfo

func (m *DNStringResponse) GetReturnStr() string {
	if m != nil {
		return m.ReturnStr
	}
	return ""
}

func init() {
	proto.RegisterEnum("ctl.CmdMethod", CmdMethod_name, CmdMethod_value)
	proto.RegisterType((*DNPingRequest)(nil), "ctl.DNPingRequest")
	proto.RegisterType((*DNPingResponse)(nil), "ctl.DNPingResponse")
	proto.RegisterType((*DNStringResponse)(nil), "ctl.DNStringResponse")
}

func init() { proto.RegisterFile("ctl.proto", fileDescriptor_0646114e50303026) }

var fileDescriptor_0646114e50303026 = []byte{
	// 367 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0x91, 0xc1, 0x6e, 0xd3, 0x40,
	0x10, 0x86, 0xd9, 0x26, 0x69, 0xf0, 0x54, 0x84, 0xd5, 0x9e, 0x2c, 0x84, 0xac, 0x2a, 0x07, 0x54,
	0x21, 0x5a, 0x23, 0x71, 0x47, 0x82, 0x58, 0xad, 0x72, 0xa0, 0x42, 0x31, 0x5c, 0xb8, 0xd9, 0xeb,
	0xc1, 0x5e, 0xc5, 0xde, 0x5d, 0x76, 0xc7, 0x15, 0xcf, 0xc4, 0x93, 0x70, 0xec, 0x23, 0x40, 0x9e,
	0x04, 0x79, 0xa9, 0x93, 0xa8, 0xb7, 0xfd, 0xbe, 0xf9, 0x77, 0x34, 0xa3, 0x81, 0x48, 0x52, 0x7b,
	0x65, 0x9d, 0x21, 0x23, 0x26, 0x92, 0xda, 0x17, 0x97, 0xb5, 0xa2, 0xa6, 0x2f, 0xaf, 0xa4, 0xe9,
	0xd2, 0xda, 0xd4, 0x26, 0x0d, 0xb5, 0xb2, 0xff, 0x1e, 0x28, 0x40, 0x78, 0xfd, 0xff, 0xb3, 0xbc,
	0x84, 0x67, 0xd9, 0xed, 0x67, 0xa5, 0xeb, 0x0d, 0xfe, 0xe8, 0xd1, 0x93, 0x78, 0x09, 0x91, 0x2d,
	0x5c, 0xd1, 0x21, 0xa1, 0x8b, 0xd9, 0x39, 0xbb, 0x88, 0x36, 0x07, 0xb1, 0xfc, 0xc5, 0x60, 0x31,
	0xe6, 0xbd, 0x35, 0xda, 0xa3, 0x88, 0x61, 0xee, 0xc9, 0x38, 0x5c, 0x67, 0x0f, 0xf1, 0x11, 0xc5,
	0x2b, 0x58, 0x78, 0x74, 0x77, 0x4a, 0xe2, 0x87, 0xaa, 0x72, 0xe8, 0x7d, 0x7c, 0x12, 0x02, 0x8f,
	0x6c, 0xe8, 0xd0, 0x14, 0xae, 0x5a, 0x67, 0xf1, 0xe4, 0x9c, 0x5d, 0x4c, 0x37, 0x23, 0x0e, 0xc3,
	0x38, 0xb4, 0xad, 0x92, 0xc5, 0x3a, 0x8b, 0xa7, 0xa1, 0x76, 0x10, 0x22, 0x01, 0x68, 0x4d, 0x9d,
	0x3f, 0x7c, 0x9d, 0x85, 0xf2, 0x91, 0x59, 0xbe, 0x05, 0x9e, 0xdd, 0xe6, 0xe4, 0x8e, 0xa7, 0x0d,
	0x1d, 0xa9, 0x77, 0x3a, 0xa7, 0xfd, 0x7a, 0x7b, 0xf1, 0xfa, 0x0e, 0xa2, 0x55, 0x57, 0x7d, 0x42,
	0x6a, 0x4c, 0x25, 0x9e, 0xc2, 0x74, 0x58, 0x94, 0x3f, 0x11, 0x11, 0xcc, 0xae, 0xdb, 0xde, 0x37,
	0x9c, 0x0d, 0xf2, 0x4b, 0xe1, 0xb7, 0xfc, 0x44, 0x2c, 0x00, 0x56, 0x0d, 0xca, 0xad, 0x35, 0x4a,
	0x13, 0x9f, 0x88, 0xe7, 0x70, 0xf6, 0xd5, 0x63, 0xae, 0x0b, 0xeb, 0x1b, 0x43, 0x7c, 0x3a, 0x88,
	0x1b, 0xa4, 0xbd, 0x98, 0x89, 0x33, 0x98, 0x5f, 0x1b, 0x27, 0xf1, 0x66, 0xc5, 0x4f, 0x07, 0x58,
	0x6b, 0x6f, 0x51, 0x12, 0x9f, 0x7f, 0x7c, 0x7f, 0xff, 0x37, 0x61, 0xbf, 0x77, 0x09, 0xbb, 0xdf,
	0x25, 0xec, 0xcf, 0x2e, 0x61, 0xdf, 0xde, 0x1c, 0x9d, 0xb1, 0x2b, 0xc8, 0xa9, 0x9f, 0xc6, 0xa9,
	0x5a, 0xe9, 0x11, 0x34, 0xa6, 0x76, 0x5b, 0xa7, 0xb6, 0x4c, 0x25, 0xb5, 0xe5, 0x69, 0x38, 0xe6,
	0xbb, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x06, 0x59, 0x5b, 0x0d, 0x02, 0x00, 0x00,
}

func (m *DNPingRequest) 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 *DNPingRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DNPingRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Parameter) > 0 {
		i -= len(m.Parameter)
		copy(dAtA[i:], m.Parameter)
		i = encodeVarintCtl(dAtA, i, uint64(len(m.Parameter)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DNPingResponse) 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 *DNPingResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DNPingResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.LogShardID != 0 {
		i = encodeVarintCtl(dAtA, i, uint64(m.LogShardID))
		i--
		dAtA[i] = 0x28
	}
	if m.ReplicaID != 0 {
		i = encodeVarintCtl(dAtA, i, uint64(m.ReplicaID))
		i--
		dAtA[i] = 0x20
	}
	if m.ShardID != 0 {
		i = encodeVarintCtl(dAtA, i, uint64(m.ShardID))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ServiceAddress) > 0 {
		i -= len(m.ServiceAddress)
		copy(dAtA[i:], m.ServiceAddress)
		i = encodeVarintCtl(dAtA, i, uint64(len(m.ServiceAddress)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.StoreID) > 0 {
		i -= len(m.StoreID)
		copy(dAtA[i:], m.StoreID)
		i = encodeVarintCtl(dAtA, i, uint64(len(m.StoreID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DNStringResponse) 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 *DNStringResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DNStringResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.ReturnStr) > 0 {
		i -= len(m.ReturnStr)
		copy(dAtA[i:], m.ReturnStr)
		i = encodeVarintCtl(dAtA, i, uint64(len(m.ReturnStr)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintCtl(dAtA []byte, offset int, v uint64) int {
	offset -= sovCtl(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DNPingRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Parameter)
	if l > 0 {
		n += 1 + l + sovCtl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DNPingResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.StoreID)
	if l > 0 {
		n += 1 + l + sovCtl(uint64(l))
	}
	l = len(m.ServiceAddress)
	if l > 0 {
		n += 1 + l + sovCtl(uint64(l))
	}
	if m.ShardID != 0 {
		n += 1 + sovCtl(uint64(m.ShardID))
	}
	if m.ReplicaID != 0 {
		n += 1 + sovCtl(uint64(m.ReplicaID))
	}
	if m.LogShardID != 0 {
		n += 1 + sovCtl(uint64(m.LogShardID))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DNStringResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ReturnStr)
	if l > 0 {
		n += 1 + l + sovCtl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovCtl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCtl(x uint64) (n int) {
	return sovCtl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DNPingRequest) 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 ErrIntOverflowCtl
			}
			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: DNPingRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DNPingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Parameter", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				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 ErrInvalidLengthCtl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCtl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Parameter = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCtl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCtl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DNPingResponse) 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 ErrIntOverflowCtl
			}
			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: DNPingResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DNPingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StoreID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				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 ErrInvalidLengthCtl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCtl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StoreID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceAddress", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				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 ErrInvalidLengthCtl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCtl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceAddress = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ShardID", wireType)
			}
			m.ShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ShardID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReplicaID", wireType)
			}
			m.ReplicaID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReplicaID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LogShardID", wireType)
			}
			m.LogShardID = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LogShardID |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipCtl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCtl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DNStringResponse) 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 ErrIntOverflowCtl
			}
			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: DNStringResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DNStringResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReturnStr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCtl
				}
				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 ErrInvalidLengthCtl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCtl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ReturnStr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCtl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthCtl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipCtl(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowCtl
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCtl
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowCtl
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthCtl
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCtl
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCtl
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCtl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCtl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCtl = fmt.Errorf("proto: unexpected end of group")
)