origin/rpc/messagequeue.pb.go

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

package rpc

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	io "io"
	math "math"
	math_bits "math/bits"
)

// 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

type SubscribeType int32

const (
	SubscribeType_Subscribe   SubscribeType = 0
	SubscribeType_Unsubscribe SubscribeType = 1
)

var SubscribeType_name = map[int32]string{
	0: "Subscribe",
	1: "Unsubscribe",
}

var SubscribeType_value = map[string]int32{
	"Subscribe":   0,
	"Unsubscribe": 1,
}

func (x SubscribeType) String() string {
	return proto.EnumName(SubscribeType_name, int32(x))
}

func (SubscribeType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2bf98a7a010f6009, []int{0}
}

type SubscribeMethod int32

const (
	SubscribeMethod_Method_Custom SubscribeMethod = 0
	SubscribeMethod_Method_Last   SubscribeMethod = 1
)

var SubscribeMethod_name = map[int32]string{
	0: "Method_Custom",
	1: "Method_Last",
}

var SubscribeMethod_value = map[string]int32{
	"Method_Custom": 0,
	"Method_Last":   1,
}

func (x SubscribeMethod) String() string {
	return proto.EnumName(SubscribeMethod_name, int32(x))
}

func (SubscribeMethod) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_2bf98a7a010f6009, []int{1}
}

type DBQueuePopReq struct {
	CustomerId           string   `protobuf:"bytes,1,opt,name=CustomerId,proto3" json:"CustomerId,omitempty"`
	QueueName            string   `protobuf:"bytes,2,opt,name=QueueName,proto3" json:"QueueName,omitempty"`
	PopStartPos          int32    `protobuf:"varint,3,opt,name=PopStartPos,proto3" json:"PopStartPos,omitempty"`
	PopNum               int32    `protobuf:"varint,4,opt,name=PopNum,proto3" json:"PopNum,omitempty"`
	PushData             []byte   `protobuf:"bytes,5,opt,name=pushData,proto3" json:"pushData,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DBQueuePopReq proto.InternalMessageInfo

func (m *DBQueuePopReq) GetCustomerId() string {
	if m != nil {
		return m.CustomerId
	}
	return ""
}

func (m *DBQueuePopReq) GetQueueName() string {
	if m != nil {
		return m.QueueName
	}
	return ""
}

func (m *DBQueuePopReq) GetPopStartPos() int32 {
	if m != nil {
		return m.PopStartPos
	}
	return 0
}

func (m *DBQueuePopReq) GetPopNum() int32 {
	if m != nil {
		return m.PopNum
	}
	return 0
}

func (m *DBQueuePopReq) GetPushData() []byte {
	if m != nil {
		return m.PushData
	}
	return nil
}

type DBQueuePopRes struct {
	QueueName            string   `protobuf:"bytes,1,opt,name=QueueName,proto3" json:"QueueName,omitempty"`
	PushData             [][]byte `protobuf:"bytes,2,rep,name=pushData,proto3" json:"pushData,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DBQueuePopRes proto.InternalMessageInfo

func (m *DBQueuePopRes) GetQueueName() string {
	if m != nil {
		return m.QueueName
	}
	return ""
}

func (m *DBQueuePopRes) GetPushData() [][]byte {
	if m != nil {
		return m.PushData
	}
	return nil
}

//订阅
type DBQueueSubscribeReq struct {
	SubType              SubscribeType   `protobuf:"varint,1,opt,name=SubType,proto3,enum=SubscribeType" json:"SubType,omitempty"`
	Method               SubscribeMethod `protobuf:"varint,2,opt,name=Method,proto3,enum=SubscribeMethod" json:"Method,omitempty"`
	CustomerId           string          `protobuf:"bytes,3,opt,name=CustomerId,proto3" json:"CustomerId,omitempty"`
	FromNodeId           int32           `protobuf:"varint,4,opt,name=FromNodeId,proto3" json:"FromNodeId,omitempty"`
	RpcMethod            string          `protobuf:"bytes,5,opt,name=RpcMethod,proto3" json:"RpcMethod,omitempty"`
	TopicName            string          `protobuf:"bytes,6,opt,name=TopicName,proto3" json:"TopicName,omitempty"`
	StartIndex           uint64          `protobuf:"varint,7,opt,name=StartIndex,proto3" json:"StartIndex,omitempty"`
	OneBatchQuantity     int32           `protobuf:"varint,8,opt,name=OneBatchQuantity,proto3" json:"OneBatchQuantity,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_DBQueueSubscribeReq proto.InternalMessageInfo

func (m *DBQueueSubscribeReq) GetSubType() SubscribeType {
	if m != nil {
		return m.SubType
	}
	return SubscribeType_Subscribe
}

func (m *DBQueueSubscribeReq) GetMethod() SubscribeMethod {
	if m != nil {
		return m.Method
	}
	return SubscribeMethod_Method_Custom
}

func (m *DBQueueSubscribeReq) GetCustomerId() string {
	if m != nil {
		return m.CustomerId
	}
	return ""
}

func (m *DBQueueSubscribeReq) GetFromNodeId() int32 {
	if m != nil {
		return m.FromNodeId
	}
	return 0
}

func (m *DBQueueSubscribeReq) GetRpcMethod() string {
	if m != nil {
		return m.RpcMethod
	}
	return ""
}

func (m *DBQueueSubscribeReq) GetTopicName() string {
	if m != nil {
		return m.TopicName
	}
	return ""
}

func (m *DBQueueSubscribeReq) GetStartIndex() uint64 {
	if m != nil {
		return m.StartIndex
	}
	return 0
}

func (m *DBQueueSubscribeReq) GetOneBatchQuantity() int32 {
	if m != nil {
		return m.OneBatchQuantity
	}
	return 0
}

type DBQueueSubscribeRes struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DBQueueSubscribeRes proto.InternalMessageInfo

type DBQueuePublishReq struct {
	TopicName            string   `protobuf:"bytes,1,opt,name=TopicName,proto3" json:"TopicName,omitempty"`
	PushData             [][]byte `protobuf:"bytes,2,rep,name=pushData,proto3" json:"pushData,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DBQueuePublishReq proto.InternalMessageInfo

func (m *DBQueuePublishReq) GetTopicName() string {
	if m != nil {
		return m.TopicName
	}
	return ""
}

func (m *DBQueuePublishReq) GetPushData() [][]byte {
	if m != nil {
		return m.PushData
	}
	return nil
}

type DBQueuePublishRes struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DBQueuePublishRes proto.InternalMessageInfo

func init() {
	proto.RegisterEnum("SubscribeType", SubscribeType_name, SubscribeType_value)
	proto.RegisterEnum("SubscribeMethod", SubscribeMethod_name, SubscribeMethod_value)
	proto.RegisterType((*DBQueuePopReq)(nil), "DBQueuePopReq")
	proto.RegisterType((*DBQueuePopRes)(nil), "DBQueuePopRes")
	proto.RegisterType((*DBQueueSubscribeReq)(nil), "DBQueueSubscribeReq")
	proto.RegisterType((*DBQueueSubscribeRes)(nil), "DBQueueSubscribeRes")
	proto.RegisterType((*DBQueuePublishReq)(nil), "DBQueuePublishReq")
	proto.RegisterType((*DBQueuePublishRes)(nil), "DBQueuePublishRes")
}

func init() { proto.RegisterFile("proto/rpcproto/messagequeue.proto", fileDescriptor_2bf98a7a010f6009) }

var fileDescriptor_2bf98a7a010f6009 = []byte{
	// 432 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x93, 0xc1, 0x6e, 0xd3, 0x30,
	0x1c, 0xc6, 0x71, 0xbb, 0x76, 0xeb, 0x7f, 0xb4, 0xeb, 0x5c, 0x81, 0x22, 0x84, 0xa2, 0xd0, 0x53,
	0xd4, 0x43, 0x27, 0x0d, 0x71, 0xe2, 0x56, 0x26, 0xa4, 0x48, 0xac, 0x64, 0xee, 0xb8, 0x70, 0x41,
	0x4e, 0x62, 0x91, 0x48, 0x24, 0xf6, 0x62, 0x5b, 0x62, 0xcf, 0xc3, 0x13, 0xf0, 0x16, 0x1c, 0x79,
	0x04, 0xd4, 0x27, 0x41, 0xb1, 0xb3, 0x2c, 0x49, 0x11, 0x37, 0xfb, 0xf7, 0xb9, 0x5f, 0xbf, 0xff,
	0xf7, 0x57, 0xe0, 0x95, 0x28, 0xb9, 0xe2, 0x17, 0xa5, 0x88, 0xed, 0x21, 0x67, 0x52, 0xd2, 0xaf,
	0xec, 0x4e, 0x33, 0xcd, 0xd6, 0x06, 0x2d, 0x7f, 0x20, 0x98, 0x5e, 0x6d, 0x6e, 0x2a, 0x12, 0x72,
	0x41, 0xd8, 0x1d, 0x76, 0x01, 0xde, 0x69, 0xa9, 0x78, 0xce, 0xca, 0x20, 0x71, 0x90, 0x87, 0xfc,
	0x09, 0x69, 0x11, 0xfc, 0x12, 0x26, 0xe6, 0xf9, 0x96, 0xe6, 0xcc, 0x19, 0x18, 0xf9, 0x11, 0x60,
	0x0f, 0x4e, 0x43, 0x2e, 0x76, 0x8a, 0x96, 0x2a, 0xe4, 0xd2, 0x19, 0x7a, 0xc8, 0x1f, 0x91, 0x36,
	0xc2, 0xcf, 0x61, 0x1c, 0x72, 0xb1, 0xd5, 0xb9, 0x73, 0x64, 0xc4, 0xfa, 0x86, 0x5f, 0xc0, 0x89,
	0xd0, 0x32, 0xbd, 0xa2, 0x8a, 0x3a, 0x23, 0x0f, 0xf9, 0x4f, 0x49, 0x73, 0x5f, 0x06, 0xdd, 0x90,
	0xb2, 0x1b, 0x02, 0xf5, 0x43, 0xb4, 0xad, 0x06, 0xde, 0xb0, 0x63, 0xf5, 0x73, 0x00, 0x8b, 0xda,
	0x6b, 0xa7, 0x23, 0x19, 0x97, 0x59, 0xc4, 0xaa, 0xb1, 0x7d, 0x38, 0xde, 0xe9, 0xe8, 0xf6, 0x5e,
	0x58, 0xbf, 0xd9, 0xe5, 0x6c, 0xdd, 0xe8, 0x15, 0x25, 0x0f, 0x32, 0xf6, 0x61, 0x7c, 0xcd, 0x54,
	0xca, 0x13, 0x33, 0xfd, 0xec, 0x72, 0xfe, 0xf8, 0xd0, 0x72, 0x52, 0xeb, 0xbd, 0x2a, 0x87, 0x07,
	0x55, 0xba, 0x00, 0xef, 0x4b, 0x9e, 0x6f, 0x79, 0xc2, 0x82, 0xa4, 0xae, 0xa3, 0x45, 0xaa, 0x29,
	0x89, 0x88, 0xeb, 0x3f, 0x1b, 0xd9, 0x29, 0x1b, 0x50, 0xa9, 0xb7, 0x5c, 0x64, 0xb1, 0xe9, 0x60,
	0x6c, 0xd5, 0x06, 0x54, 0xde, 0xa6, 0xf2, 0xa0, 0x48, 0xd8, 0x77, 0xe7, 0xd8, 0x43, 0xfe, 0x11,
	0x69, 0x11, 0xbc, 0x82, 0xf9, 0xc7, 0x82, 0x6d, 0xa8, 0x8a, 0xd3, 0x1b, 0x4d, 0x0b, 0x95, 0xa9,
	0x7b, 0xe7, 0xc4, 0x24, 0x38, 0xe0, 0xcb, 0x67, 0xff, 0xaa, 0x4c, 0x2e, 0xaf, 0xe1, 0xfc, 0x61,
	0x2b, 0x3a, 0xfa, 0x96, 0xc9, 0xb4, 0xea, 0xb1, 0x93, 0x0a, 0xf5, 0x53, 0xfd, 0x6f, 0x33, 0x8b,
	0x43, 0x3b, 0xb9, 0xba, 0x80, 0x69, 0x67, 0x0d, 0x78, 0x0a, 0x93, 0x06, 0xcc, 0x9f, 0xe0, 0x33,
	0x38, 0xfd, 0x54, 0xc8, 0x06, 0xa0, 0xd5, 0x1b, 0x38, 0xeb, 0xad, 0x03, 0x9f, 0xc3, 0xd4, 0x9e,
	0xbe, 0xd8, 0xee, 0xed, 0xcf, 0x6a, 0xf4, 0x81, 0x4a, 0x35, 0x47, 0x9b, 0xc5, 0xaf, 0xbd, 0x8b,
	0x7e, 0xef, 0x5d, 0xf4, 0x67, 0xef, 0xa2, 0xcf, 0xa3, 0xf5, 0xdb, 0x52, 0xc4, 0xd1, 0xd8, 0x7c,
	0x23, 0xaf, 0xff, 0x06, 0x00, 0x00, 0xff, 0xff, 0x86, 0xbb, 0x7c, 0xa8, 0x48, 0x03, 0x00, 0x00,
}

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

func (m *DBQueuePopReq) 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.PushData) > 0 {
		i -= len(m.PushData)
		copy(dAtA[i:], m.PushData)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.PushData)))
		i--
		dAtA[i] = 0x2a
	}
	if m.PopNum != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.PopNum))
		i--
		dAtA[i] = 0x20
	}
	if m.PopStartPos != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.PopStartPos))
		i--
		dAtA[i] = 0x18
	}
	if len(m.QueueName) > 0 {
		i -= len(m.QueueName)
		copy(dAtA[i:], m.QueueName)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.QueueName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.CustomerId) > 0 {
		i -= len(m.CustomerId)
		copy(dAtA[i:], m.CustomerId)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.CustomerId)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DBQueuePopRes) 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.PushData) > 0 {
		for iNdEx := len(m.PushData) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PushData[iNdEx])
			copy(dAtA[i:], m.PushData[iNdEx])
			i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.PushData[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.QueueName) > 0 {
		i -= len(m.QueueName)
		copy(dAtA[i:], m.QueueName)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.QueueName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DBQueueSubscribeReq) 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.OneBatchQuantity != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.OneBatchQuantity))
		i--
		dAtA[i] = 0x40
	}
	if m.StartIndex != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.StartIndex))
		i--
		dAtA[i] = 0x38
	}
	if len(m.TopicName) > 0 {
		i -= len(m.TopicName)
		copy(dAtA[i:], m.TopicName)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.TopicName)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.RpcMethod) > 0 {
		i -= len(m.RpcMethod)
		copy(dAtA[i:], m.RpcMethod)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.RpcMethod)))
		i--
		dAtA[i] = 0x2a
	}
	if m.FromNodeId != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.FromNodeId))
		i--
		dAtA[i] = 0x20
	}
	if len(m.CustomerId) > 0 {
		i -= len(m.CustomerId)
		copy(dAtA[i:], m.CustomerId)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.CustomerId)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Method != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.Method))
		i--
		dAtA[i] = 0x10
	}
	if m.SubType != 0 {
		i = encodeVarintMessagequeue(dAtA, i, uint64(m.SubType))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *DBQueueSubscribeRes) 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)
	}
	return len(dAtA) - i, nil
}

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

func (m *DBQueuePublishReq) 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.PushData) > 0 {
		for iNdEx := len(m.PushData) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.PushData[iNdEx])
			copy(dAtA[i:], m.PushData[iNdEx])
			i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.PushData[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.TopicName) > 0 {
		i -= len(m.TopicName)
		copy(dAtA[i:], m.TopicName)
		i = encodeVarintMessagequeue(dAtA, i, uint64(len(m.TopicName)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DBQueuePublishRes) 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)
	}
	return len(dAtA) - i, nil
}

func encodeVarintMessagequeue(dAtA []byte, offset int, v uint64) int {
	offset -= sovMessagequeue(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *DBQueuePopReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.CustomerId)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	l = len(m.QueueName)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	if m.PopStartPos != 0 {
		n += 1 + sovMessagequeue(uint64(m.PopStartPos))
	}
	if m.PopNum != 0 {
		n += 1 + sovMessagequeue(uint64(m.PopNum))
	}
	l = len(m.PushData)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DBQueuePopRes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.QueueName)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	if len(m.PushData) > 0 {
		for _, b := range m.PushData {
			l = len(b)
			n += 1 + l + sovMessagequeue(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DBQueueSubscribeReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.SubType != 0 {
		n += 1 + sovMessagequeue(uint64(m.SubType))
	}
	if m.Method != 0 {
		n += 1 + sovMessagequeue(uint64(m.Method))
	}
	l = len(m.CustomerId)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	if m.FromNodeId != 0 {
		n += 1 + sovMessagequeue(uint64(m.FromNodeId))
	}
	l = len(m.RpcMethod)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	l = len(m.TopicName)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	if m.StartIndex != 0 {
		n += 1 + sovMessagequeue(uint64(m.StartIndex))
	}
	if m.OneBatchQuantity != 0 {
		n += 1 + sovMessagequeue(uint64(m.OneBatchQuantity))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DBQueueSubscribeRes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DBQueuePublishReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.TopicName)
	if l > 0 {
		n += 1 + l + sovMessagequeue(uint64(l))
	}
	if len(m.PushData) > 0 {
		for _, b := range m.PushData {
			l = len(b)
			n += 1 + l + sovMessagequeue(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DBQueuePublishRes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovMessagequeue(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozMessagequeue(x uint64) (n int) {
	return sovMessagequeue(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DBQueuePopReq) 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 ErrIntOverflowMessagequeue
			}
			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: DBQueuePopReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBQueuePopReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CustomerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueueName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopStartPos", wireType)
			}
			m.PopStartPos = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopStartPos |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PopNum", wireType)
			}
			m.PopNum = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PopNum |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PushData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PushData = append(m.PushData[:0], dAtA[iNdEx:postIndex]...)
			if m.PushData == nil {
				m.PushData = []byte{}
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessagequeue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessagequeue
			}
			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 *DBQueuePopRes) 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 ErrIntOverflowMessagequeue
			}
			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: DBQueuePopRes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBQueuePopRes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueueName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueueName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PushData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PushData = append(m.PushData, make([]byte, postIndex-iNdEx))
			copy(m.PushData[len(m.PushData)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessagequeue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessagequeue
			}
			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 *DBQueueSubscribeReq) 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 ErrIntOverflowMessagequeue
			}
			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: DBQueueSubscribeReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBQueueSubscribeReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field SubType", wireType)
			}
			m.SubType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.SubType |= SubscribeType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
			}
			m.Method = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Method |= SubscribeMethod(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CustomerId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CustomerId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field FromNodeId", wireType)
			}
			m.FromNodeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.FromNodeId |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RpcMethod", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RpcMethod = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StartIndex", wireType)
			}
			m.StartIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StartIndex |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field OneBatchQuantity", wireType)
			}
			m.OneBatchQuantity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.OneBatchQuantity |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipMessagequeue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessagequeue
			}
			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 *DBQueueSubscribeRes) 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 ErrIntOverflowMessagequeue
			}
			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: DBQueueSubscribeRes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBQueueSubscribeRes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMessagequeue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessagequeue
			}
			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 *DBQueuePublishReq) 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 ErrIntOverflowMessagequeue
			}
			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: DBQueuePublishReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBQueuePublishReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TopicName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				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 ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TopicName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PushData", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowMessagequeue
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthMessagequeue
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PushData = append(m.PushData, make([]byte, postIndex-iNdEx))
			copy(m.PushData[len(m.PushData)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipMessagequeue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessagequeue
			}
			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 *DBQueuePublishRes) 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 ErrIntOverflowMessagequeue
			}
			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: DBQueuePublishRes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DBQueuePublishRes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipMessagequeue(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthMessagequeue
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthMessagequeue
			}
			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 skipMessagequeue(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, ErrIntOverflowMessagequeue
			}
			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, ErrIntOverflowMessagequeue
				}
				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, ErrIntOverflowMessagequeue
				}
				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, ErrInvalidLengthMessagequeue
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupMessagequeue
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthMessagequeue
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthMessagequeue        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessagequeue          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupMessagequeue = fmt.Errorf("proto: unexpected end of group")
)