group.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: group.proto

package kv

import (
	context "context"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	math "math"
)

// 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.ProtoPackageIsVersion3 // please upgrade the proto package

type PutAppendArgs struct {
	Key                  string   `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=Value,proto3" json:"Value,omitempty"`
	Op                   string   `protobuf:"bytes,3,opt,name=Op,proto3" json:"Op,omitempty"`
	ClientId             int64    `protobuf:"zigzag64,4,opt,name=ClientId,proto3" json:"ClientId,omitempty"`
	Sequence             int64    `protobuf:"zigzag64,5,opt,name=Sequence,proto3" json:"Sequence,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PutAppendArgs) Reset()         { *m = PutAppendArgs{} }
func (m *PutAppendArgs) String() string { return proto.CompactTextString(m) }
func (*PutAppendArgs) ProtoMessage()    {}
func (*PutAppendArgs) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{0}
}

func (m *PutAppendArgs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PutAppendArgs.Unmarshal(m, b)
}
func (m *PutAppendArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PutAppendArgs.Marshal(b, m, deterministic)
}
func (m *PutAppendArgs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PutAppendArgs.Merge(m, src)
}
func (m *PutAppendArgs) XXX_Size() int {
	return xxx_messageInfo_PutAppendArgs.Size(m)
}
func (m *PutAppendArgs) XXX_DiscardUnknown() {
	xxx_messageInfo_PutAppendArgs.DiscardUnknown(m)
}

var xxx_messageInfo_PutAppendArgs proto.InternalMessageInfo

func (m *PutAppendArgs) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *PutAppendArgs) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *PutAppendArgs) GetOp() string {
	if m != nil {
		return m.Op
	}
	return ""
}

func (m *PutAppendArgs) GetClientId() int64 {
	if m != nil {
		return m.ClientId
	}
	return 0
}

func (m *PutAppendArgs) GetSequence() int64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

type PutAppendReply struct {
	WrongLeader          bool     `protobuf:"varint,1,opt,name=WrongLeader,proto3" json:"WrongLeader,omitempty"`
	Err                  string   `protobuf:"bytes,2,opt,name=Err,proto3" json:"Err,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PutAppendReply) Reset()         { *m = PutAppendReply{} }
func (m *PutAppendReply) String() string { return proto.CompactTextString(m) }
func (*PutAppendReply) ProtoMessage()    {}
func (*PutAppendReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{1}
}

func (m *PutAppendReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PutAppendReply.Unmarshal(m, b)
}
func (m *PutAppendReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PutAppendReply.Marshal(b, m, deterministic)
}
func (m *PutAppendReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PutAppendReply.Merge(m, src)
}
func (m *PutAppendReply) XXX_Size() int {
	return xxx_messageInfo_PutAppendReply.Size(m)
}
func (m *PutAppendReply) XXX_DiscardUnknown() {
	xxx_messageInfo_PutAppendReply.DiscardUnknown(m)
}

var xxx_messageInfo_PutAppendReply proto.InternalMessageInfo

func (m *PutAppendReply) GetWrongLeader() bool {
	if m != nil {
		return m.WrongLeader
	}
	return false
}

func (m *PutAppendReply) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

type GetArgs struct {
	Key                  string   `protobuf:"bytes,1,opt,name=Key,proto3" json:"Key,omitempty"`
	ClientId             int64    `protobuf:"zigzag64,2,opt,name=ClientId,proto3" json:"ClientId,omitempty"`
	Sequence             int64    `protobuf:"zigzag64,3,opt,name=Sequence,proto3" json:"Sequence,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetArgs) Reset()         { *m = GetArgs{} }
func (m *GetArgs) String() string { return proto.CompactTextString(m) }
func (*GetArgs) ProtoMessage()    {}
func (*GetArgs) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{2}
}

func (m *GetArgs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetArgs.Unmarshal(m, b)
}
func (m *GetArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetArgs.Marshal(b, m, deterministic)
}
func (m *GetArgs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetArgs.Merge(m, src)
}
func (m *GetArgs) XXX_Size() int {
	return xxx_messageInfo_GetArgs.Size(m)
}
func (m *GetArgs) XXX_DiscardUnknown() {
	xxx_messageInfo_GetArgs.DiscardUnknown(m)
}

var xxx_messageInfo_GetArgs proto.InternalMessageInfo

func (m *GetArgs) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *GetArgs) GetClientId() int64 {
	if m != nil {
		return m.ClientId
	}
	return 0
}

func (m *GetArgs) GetSequence() int64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

type GetReply struct {
	WrongLeader          bool     `protobuf:"varint,1,opt,name=WrongLeader,proto3" json:"WrongLeader,omitempty"`
	Err                  string   `protobuf:"bytes,2,opt,name=Err,proto3" json:"Err,omitempty"`
	Value                string   `protobuf:"bytes,3,opt,name=Value,proto3" json:"Value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GetReply) Reset()         { *m = GetReply{} }
func (m *GetReply) String() string { return proto.CompactTextString(m) }
func (*GetReply) ProtoMessage()    {}
func (*GetReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{3}
}

func (m *GetReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GetReply.Unmarshal(m, b)
}
func (m *GetReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GetReply.Marshal(b, m, deterministic)
}
func (m *GetReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GetReply.Merge(m, src)
}
func (m *GetReply) XXX_Size() int {
	return xxx_messageInfo_GetReply.Size(m)
}
func (m *GetReply) XXX_DiscardUnknown() {
	xxx_messageInfo_GetReply.DiscardUnknown(m)
}

var xxx_messageInfo_GetReply proto.InternalMessageInfo

func (m *GetReply) GetWrongLeader() bool {
	if m != nil {
		return m.WrongLeader
	}
	return false
}

func (m *GetReply) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

func (m *GetReply) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

type ClearShardArgs struct {
	Num                  int32    `protobuf:"varint,1,opt,name=Num,proto3" json:"Num,omitempty"`
	ShardIndex           int32    `protobuf:"varint,2,opt,name=ShardIndex,proto3" json:"ShardIndex,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClearShardArgs) Reset()         { *m = ClearShardArgs{} }
func (m *ClearShardArgs) String() string { return proto.CompactTextString(m) }
func (*ClearShardArgs) ProtoMessage()    {}
func (*ClearShardArgs) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{4}
}

func (m *ClearShardArgs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClearShardArgs.Unmarshal(m, b)
}
func (m *ClearShardArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClearShardArgs.Marshal(b, m, deterministic)
}
func (m *ClearShardArgs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClearShardArgs.Merge(m, src)
}
func (m *ClearShardArgs) XXX_Size() int {
	return xxx_messageInfo_ClearShardArgs.Size(m)
}
func (m *ClearShardArgs) XXX_DiscardUnknown() {
	xxx_messageInfo_ClearShardArgs.DiscardUnknown(m)
}

var xxx_messageInfo_ClearShardArgs proto.InternalMessageInfo

func (m *ClearShardArgs) GetNum() int32 {
	if m != nil {
		return m.Num
	}
	return 0
}

func (m *ClearShardArgs) GetShardIndex() int32 {
	if m != nil {
		return m.ShardIndex
	}
	return 0
}

type ClearShardReply struct {
	WrongLeader          bool     `protobuf:"varint,1,opt,name=WrongLeader,proto3" json:"WrongLeader,omitempty"`
	Err                  string   `protobuf:"bytes,2,opt,name=Err,proto3" json:"Err,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ClearShardReply) Reset()         { *m = ClearShardReply{} }
func (m *ClearShardReply) String() string { return proto.CompactTextString(m) }
func (*ClearShardReply) ProtoMessage()    {}
func (*ClearShardReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{5}
}

func (m *ClearShardReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ClearShardReply.Unmarshal(m, b)
}
func (m *ClearShardReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ClearShardReply.Marshal(b, m, deterministic)
}
func (m *ClearShardReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ClearShardReply.Merge(m, src)
}
func (m *ClearShardReply) XXX_Size() int {
	return xxx_messageInfo_ClearShardReply.Size(m)
}
func (m *ClearShardReply) XXX_DiscardUnknown() {
	xxx_messageInfo_ClearShardReply.DiscardUnknown(m)
}

var xxx_messageInfo_ClearShardReply proto.InternalMessageInfo

func (m *ClearShardReply) GetWrongLeader() bool {
	if m != nil {
		return m.WrongLeader
	}
	return false
}

func (m *ClearShardReply) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

type TransferShardArgs struct {
	Num                  int32    `protobuf:"varint,1,opt,name=Num,proto3" json:"Num,omitempty"`
	ShardIds             []int32  `protobuf:"varint,2,rep,packed,name=ShardIds,proto3" json:"ShardIds,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TransferShardArgs) Reset()         { *m = TransferShardArgs{} }
func (m *TransferShardArgs) String() string { return proto.CompactTextString(m) }
func (*TransferShardArgs) ProtoMessage()    {}
func (*TransferShardArgs) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{6}
}

func (m *TransferShardArgs) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransferShardArgs.Unmarshal(m, b)
}
func (m *TransferShardArgs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransferShardArgs.Marshal(b, m, deterministic)
}
func (m *TransferShardArgs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransferShardArgs.Merge(m, src)
}
func (m *TransferShardArgs) XXX_Size() int {
	return xxx_messageInfo_TransferShardArgs.Size(m)
}
func (m *TransferShardArgs) XXX_DiscardUnknown() {
	xxx_messageInfo_TransferShardArgs.DiscardUnknown(m)
}

var xxx_messageInfo_TransferShardArgs proto.InternalMessageInfo

func (m *TransferShardArgs) GetNum() int32 {
	if m != nil {
		return m.Num
	}
	return 0
}

func (m *TransferShardArgs) GetShardIds() []int32 {
	if m != nil {
		return m.ShardIds
	}
	return nil
}

type TransferShardReply struct {
	Err                  string          `protobuf:"bytes,1,opt,name=Err,proto3" json:"Err,omitempty"`
	Data                 []*KVData       `protobuf:"bytes,2,rep,name=Data,proto3" json:"Data,omitempty"`
	ClientToSeq          map[int64]int64 `protobuf:"bytes,3,rep,name=ClientToSeq,proto3" json:"ClientToSeq,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *TransferShardReply) Reset()         { *m = TransferShardReply{} }
func (m *TransferShardReply) String() string { return proto.CompactTextString(m) }
func (*TransferShardReply) ProtoMessage()    {}
func (*TransferShardReply) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{7}
}

func (m *TransferShardReply) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TransferShardReply.Unmarshal(m, b)
}
func (m *TransferShardReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TransferShardReply.Marshal(b, m, deterministic)
}
func (m *TransferShardReply) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TransferShardReply.Merge(m, src)
}
func (m *TransferShardReply) XXX_Size() int {
	return xxx_messageInfo_TransferShardReply.Size(m)
}
func (m *TransferShardReply) XXX_DiscardUnknown() {
	xxx_messageInfo_TransferShardReply.DiscardUnknown(m)
}

var xxx_messageInfo_TransferShardReply proto.InternalMessageInfo

func (m *TransferShardReply) GetErr() string {
	if m != nil {
		return m.Err
	}
	return ""
}

func (m *TransferShardReply) GetData() []*KVData {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *TransferShardReply) GetClientToSeq() map[int64]int64 {
	if m != nil {
		return m.ClientToSeq
	}
	return nil
}

type KVOp struct {
	Command              string          `protobuf:"bytes,1,opt,name=Command,proto3" json:"Command,omitempty"`
	ClientId             int64           `protobuf:"zigzag64,2,opt,name=ClientId,proto3" json:"ClientId,omitempty"`
	Sequence             int64           `protobuf:"zigzag64,3,opt,name=Sequence,proto3" json:"Sequence,omitempty"`
	Key                  string          `protobuf:"bytes,4,opt,name=Key,proto3" json:"Key,omitempty"`
	Value                string          `protobuf:"bytes,5,opt,name=Value,proto3" json:"Value,omitempty"`
	ConfigNum            int32           `protobuf:"varint,6,opt,name=ConfigNum,proto3" json:"ConfigNum,omitempty"`
	ShardIndex           int32           `protobuf:"varint,7,opt,name=ShardIndex,proto3" json:"ShardIndex,omitempty"`
	ClientToSeq          map[int64]int64 `protobuf:"bytes,8,rep,name=ClientToSeq,proto3" json:"ClientToSeq,omitempty" protobuf_key:"zigzag64,1,opt,name=key,proto3" protobuf_val:"zigzag64,2,opt,name=value,proto3"`
	Data                 []*KVData       `protobuf:"bytes,9,rep,name=Data,proto3" json:"Data,omitempty"`
	MasterConfig         *Config         `protobuf:"bytes,10,opt,name=MasterConfig,proto3" json:"MasterConfig,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

func (m *KVOp) Reset()         { *m = KVOp{} }
func (m *KVOp) String() string { return proto.CompactTextString(m) }
func (*KVOp) ProtoMessage()    {}
func (*KVOp) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{8}
}

func (m *KVOp) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KVOp.Unmarshal(m, b)
}
func (m *KVOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KVOp.Marshal(b, m, deterministic)
}
func (m *KVOp) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KVOp.Merge(m, src)
}
func (m *KVOp) XXX_Size() int {
	return xxx_messageInfo_KVOp.Size(m)
}
func (m *KVOp) XXX_DiscardUnknown() {
	xxx_messageInfo_KVOp.DiscardUnknown(m)
}

var xxx_messageInfo_KVOp proto.InternalMessageInfo

func (m *KVOp) GetCommand() string {
	if m != nil {
		return m.Command
	}
	return ""
}

func (m *KVOp) GetClientId() int64 {
	if m != nil {
		return m.ClientId
	}
	return 0
}

func (m *KVOp) GetSequence() int64 {
	if m != nil {
		return m.Sequence
	}
	return 0
}

func (m *KVOp) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *KVOp) GetValue() string {
	if m != nil {
		return m.Value
	}
	return ""
}

func (m *KVOp) GetConfigNum() int32 {
	if m != nil {
		return m.ConfigNum
	}
	return 0
}

func (m *KVOp) GetShardIndex() int32 {
	if m != nil {
		return m.ShardIndex
	}
	return 0
}

func (m *KVOp) GetClientToSeq() map[int64]int64 {
	if m != nil {
		return m.ClientToSeq
	}
	return nil
}

func (m *KVOp) GetData() []*KVData {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *KVOp) GetMasterConfig() *Config {
	if m != nil {
		return m.MasterConfig
	}
	return nil
}

type KVData struct {
	Store                map[string]string `protobuf:"bytes,1,rep,name=store,proto3" json:"store,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *KVData) Reset()         { *m = KVData{} }
func (m *KVData) String() string { return proto.CompactTextString(m) }
func (*KVData) ProtoMessage()    {}
func (*KVData) Descriptor() ([]byte, []int) {
	return fileDescriptor_e10f4c9b19ad8eee, []int{9}
}

func (m *KVData) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KVData.Unmarshal(m, b)
}
func (m *KVData) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KVData.Marshal(b, m, deterministic)
}
func (m *KVData) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KVData.Merge(m, src)
}
func (m *KVData) XXX_Size() int {
	return xxx_messageInfo_KVData.Size(m)
}
func (m *KVData) XXX_DiscardUnknown() {
	xxx_messageInfo_KVData.DiscardUnknown(m)
}

var xxx_messageInfo_KVData proto.InternalMessageInfo

func (m *KVData) GetStore() map[string]string {
	if m != nil {
		return m.Store
	}
	return nil
}

func init() {
	proto.RegisterType((*PutAppendArgs)(nil), "kv.PutAppendArgs")
	proto.RegisterType((*PutAppendReply)(nil), "kv.PutAppendReply")
	proto.RegisterType((*GetArgs)(nil), "kv.GetArgs")
	proto.RegisterType((*GetReply)(nil), "kv.GetReply")
	proto.RegisterType((*ClearShardArgs)(nil), "kv.ClearShardArgs")
	proto.RegisterType((*ClearShardReply)(nil), "kv.ClearShardReply")
	proto.RegisterType((*TransferShardArgs)(nil), "kv.TransferShardArgs")
	proto.RegisterType((*TransferShardReply)(nil), "kv.TransferShardReply")
	proto.RegisterMapType((map[int64]int64)(nil), "kv.TransferShardReply.ClientToSeqEntry")
	proto.RegisterType((*KVOp)(nil), "kv.KVOp")
	proto.RegisterMapType((map[int64]int64)(nil), "kv.KVOp.ClientToSeqEntry")
	proto.RegisterType((*KVData)(nil), "kv.KVData")
	proto.RegisterMapType((map[string]string)(nil), "kv.KVData.StoreEntry")
}

func init() { proto.RegisterFile("group.proto", fileDescriptor_e10f4c9b19ad8eee) }

var fileDescriptor_e10f4c9b19ad8eee = []byte{
	// 592 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xdd, 0x8e, 0xd2, 0x40,
	0x14, 0xde, 0xb6, 0x14, 0xe8, 0x81, 0xc5, 0xdd, 0xa3, 0x6b, 0x6a, 0x63, 0x36, 0xa4, 0x37, 0x92,
	0x98, 0xf4, 0x62, 0x35, 0x71, 0xa3, 0x89, 0x11, 0x59, 0x42, 0x08, 0x2a, 0x66, 0x20, 0x78, 0x5d,
	0xed, 0x2c, 0x6e, 0x80, 0xb6, 0x3b, 0x14, 0x22, 0x57, 0x3e, 0x80, 0x4f, 0xe7, 0xbd, 0x0f, 0x63,
	0x66, 0xa6, 0xbf, 0x2c, 0xcb, 0x05, 0x7b, 0x37, 0xe7, 0x9b, 0x33, 0xe7, 0x7c, 0xf3, 0x9d, 0x1f,
	0xa8, 0x4d, 0x59, 0xb0, 0x0a, 0x9d, 0x90, 0x05, 0x51, 0x80, 0xea, 0x6c, 0x6d, 0xd5, 0x17, 0xee,
	0x32, 0xa2, 0x4c, 0x22, 0xf6, 0x6f, 0x38, 0xfe, 0xba, 0x8a, 0xda, 0x61, 0x48, 0x7d, 0xaf, 0xcd,
	0xa6, 0x4b, 0x3c, 0x01, 0x6d, 0x40, 0x37, 0xa6, 0xd2, 0x54, 0x5a, 0x06, 0xe1, 0x47, 0x7c, 0x02,
	0xfa, 0xc4, 0x9d, 0xaf, 0xa8, 0xa9, 0x0a, 0x4c, 0x1a, 0xd8, 0x00, 0x75, 0x18, 0x9a, 0x9a, 0x80,
	0xd4, 0x61, 0x88, 0x16, 0x54, 0x3b, 0xf3, 0x1b, 0xea, 0x47, 0x7d, 0xcf, 0x2c, 0x35, 0x95, 0x16,
	0x92, 0xd4, 0xe6, 0x77, 0x23, 0x7a, 0xbb, 0xa2, 0xfe, 0x0f, 0x6a, 0xea, 0xf2, 0x2e, 0xb1, 0xed,
	0x2b, 0x68, 0xa4, 0x04, 0x08, 0x0d, 0xe7, 0x1b, 0x6c, 0x42, 0xed, 0x1b, 0x0b, 0xfc, 0xe9, 0x27,
	0xea, 0x7a, 0x94, 0x09, 0x26, 0x55, 0x92, 0x87, 0x38, 0xc7, 0x2e, 0x63, 0x31, 0x1f, 0x7e, 0xb4,
	0x47, 0x50, 0xe9, 0xd1, 0xe8, 0x9e, 0x0f, 0xe4, 0xa9, 0xa9, 0x7b, 0xa8, 0x69, 0x5b, 0xd4, 0xc6,
	0x50, 0xed, 0xd1, 0xe8, 0x60, 0x52, 0x99, 0x70, 0x5a, 0x4e, 0x38, 0xfb, 0x23, 0x34, 0x3a, 0x73,
	0xea, 0xb2, 0xd1, 0x4f, 0x97, 0xa5, 0x92, 0x7f, 0x59, 0x2d, 0x44, 0x4c, 0x9d, 0xf0, 0x23, 0x9e,
	0x03, 0x88, 0xeb, 0xbe, 0xef, 0xd1, 0x5f, 0x22, 0xa4, 0x4e, 0x72, 0x88, 0xdd, 0x85, 0x47, 0x59,
	0x8c, 0xc3, 0x55, 0x6b, 0xc3, 0xe9, 0x98, 0xb9, 0xfe, 0xf2, 0x9a, 0xee, 0x65, 0xc3, 0x35, 0x12,
	0xb9, 0xbd, 0xa5, 0xa9, 0x36, 0xb5, 0x96, 0x4e, 0x52, 0xdb, 0xfe, 0xab, 0x00, 0x16, 0x62, 0x48,
	0x36, 0x71, 0x2e, 0x25, 0x13, 0xe3, 0x1c, 0x4a, 0x57, 0x6e, 0xe4, 0x8a, 0x00, 0xb5, 0x0b, 0x70,
	0x66, 0x6b, 0x67, 0x30, 0xe1, 0x08, 0x11, 0x38, 0xf6, 0xa1, 0x26, 0x8b, 0x32, 0x0e, 0x46, 0xf4,
	0xd6, 0xd4, 0x84, 0xdb, 0x0b, 0xee, 0x76, 0x37, 0xbc, 0x93, 0xf3, 0xec, 0xfa, 0x11, 0xdb, 0x90,
	0xfc, 0x5b, 0xeb, 0x3d, 0x9c, 0x6c, 0x3b, 0x70, 0x42, 0xb3, 0xb8, 0x2b, 0x90, 0xf0, 0x23, 0xaf,
	0xce, 0x3a, 0x6d, 0x6b, 0x24, 0xd2, 0x78, 0xab, 0x5e, 0x2a, 0xf6, 0x1f, 0x0d, 0x4a, 0x83, 0xc9,
	0x30, 0x44, 0x13, 0x2a, 0x9d, 0x60, 0xb1, 0x70, 0x7d, 0x2f, 0xfe, 0x49, 0x62, 0x1e, 0xda, 0x52,
	0x49, 0x73, 0x96, 0x76, 0x4c, 0x97, 0x9e, 0x9f, 0xae, 0xe7, 0x60, 0x74, 0x02, 0xff, 0xfa, 0x66,
	0xca, 0x4b, 0x51, 0x16, 0xa5, 0xc8, 0x80, 0xad, 0xf6, 0xa8, 0x6c, 0xb7, 0x07, 0xbe, 0x2b, 0x6a,
	0x59, 0x15, 0x5a, 0x3e, 0x93, 0x92, 0x0f, 0xc3, 0xfd, 0xea, 0xa5, 0x85, 0x32, 0xee, 0x29, 0x94,
	0x03, 0xf5, 0xcf, 0x62, 0x83, 0x48, 0x3e, 0x26, 0x34, 0x95, 0xc4, 0x4f, 0x22, 0xa4, 0x70, 0xff,
	0xe0, 0x6a, 0x04, 0x50, 0x96, 0xf9, 0xf1, 0x25, 0xe8, 0xcb, 0x28, 0x60, 0xd4, 0x54, 0x04, 0xb5,
	0xb3, 0x8c, 0x9a, 0x33, 0xe2, 0xb8, 0xfc, 0x8c, 0xf4, 0xb1, 0x2e, 0x01, 0x32, 0x30, 0x9f, 0xd0,
	0xd8, 0x91, 0xd0, 0xc8, 0x25, 0xbc, 0xf8, 0xa7, 0x80, 0xde, 0xe3, 0x4b, 0x13, 0x5f, 0x83, 0x91,
	0xee, 0x26, 0x3c, 0xe5, 0xe9, 0x0a, 0xbb, 0xd2, 0xc2, 0x02, 0x24, 0x5a, 0xd3, 0x3e, 0x42, 0x1b,
	0xb4, 0x1e, 0x8d, 0xb0, 0xc6, 0x2f, 0xe3, 0xa5, 0x64, 0xd5, 0x63, 0x23, 0xf1, 0x79, 0x03, 0x90,
	0x0d, 0x30, 0x8a, 0x38, 0xc5, 0xa5, 0x60, 0x3d, 0x2e, 0x62, 0xc9, 0xc3, 0x0f, 0x70, 0x5c, 0x98,
	0x07, 0x3c, 0xbb, 0x33, 0x22, 0xe2, 0xf9, 0xd3, 0xdd, 0x93, 0x63, 0x1f, 0x7d, 0x2f, 0x8b, 0xc5,
	0xff, 0xea, 0x7f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x0b, 0x8d, 0x10, 0xfe, 0x19, 0x06, 0x00, 0x00,
}

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConnInterface

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion6

// GroupClient is the client API for Group service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type GroupClient interface {
	// Put or Append
	PutAppend(ctx context.Context, in *PutAppendArgs, opts ...grpc.CallOption) (*PutAppendReply, error)
	// Get
	Get(ctx context.Context, in *GetArgs, opts ...grpc.CallOption) (*GetReply, error)
	// Clear Shard
	ClearShard(ctx context.Context, in *ClearShardArgs, opts ...grpc.CallOption) (*ClearShardReply, error)
	// Transfer Shard
	TransferShard(ctx context.Context, in *TransferShardArgs, opts ...grpc.CallOption) (*TransferShardReply, error)
}

type groupClient struct {
	cc grpc.ClientConnInterface
}

func NewGroupClient(cc grpc.ClientConnInterface) GroupClient {
	return &groupClient{cc}
}

func (c *groupClient) PutAppend(ctx context.Context, in *PutAppendArgs, opts ...grpc.CallOption) (*PutAppendReply, error) {
	out := new(PutAppendReply)
	err := c.cc.Invoke(ctx, "/kv.Group/PutAppend", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupClient) Get(ctx context.Context, in *GetArgs, opts ...grpc.CallOption) (*GetReply, error) {
	out := new(GetReply)
	err := c.cc.Invoke(ctx, "/kv.Group/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupClient) ClearShard(ctx context.Context, in *ClearShardArgs, opts ...grpc.CallOption) (*ClearShardReply, error) {
	out := new(ClearShardReply)
	err := c.cc.Invoke(ctx, "/kv.Group/ClearShard", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *groupClient) TransferShard(ctx context.Context, in *TransferShardArgs, opts ...grpc.CallOption) (*TransferShardReply, error) {
	out := new(TransferShardReply)
	err := c.cc.Invoke(ctx, "/kv.Group/TransferShard", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// GroupServer is the server API for Group service.
type GroupServer interface {
	// Put or Append
	PutAppend(context.Context, *PutAppendArgs) (*PutAppendReply, error)
	// Get
	Get(context.Context, *GetArgs) (*GetReply, error)
	// Clear Shard
	ClearShard(context.Context, *ClearShardArgs) (*ClearShardReply, error)
	// Transfer Shard
	TransferShard(context.Context, *TransferShardArgs) (*TransferShardReply, error)
}

// UnimplementedGroupServer can be embedded to have forward compatible implementations.
type UnimplementedGroupServer struct {
}

func (*UnimplementedGroupServer) PutAppend(ctx context.Context, req *PutAppendArgs) (*PutAppendReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PutAppend not implemented")
}
func (*UnimplementedGroupServer) Get(ctx context.Context, req *GetArgs) (*GetReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedGroupServer) ClearShard(ctx context.Context, req *ClearShardArgs) (*ClearShardReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ClearShard not implemented")
}
func (*UnimplementedGroupServer) TransferShard(ctx context.Context, req *TransferShardArgs) (*TransferShardReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TransferShard not implemented")
}

func RegisterGroupServer(s *grpc.Server, srv GroupServer) {
	s.RegisterService(&_Group_serviceDesc, srv)
}

func _Group_PutAppend_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PutAppendArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupServer).PutAppend(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kv.Group/PutAppend",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServer).PutAppend(ctx, req.(*PutAppendArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _Group_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kv.Group/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServer).Get(ctx, req.(*GetArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _Group_ClearShard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClearShardArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupServer).ClearShard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kv.Group/ClearShard",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServer).ClearShard(ctx, req.(*ClearShardArgs))
	}
	return interceptor(ctx, in, info, handler)
}

func _Group_TransferShard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TransferShardArgs)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(GroupServer).TransferShard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/kv.Group/TransferShard",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(GroupServer).TransferShard(ctx, req.(*TransferShardArgs))
	}
	return interceptor(ctx, in, info, handler)
}

var _Group_serviceDesc = grpc.ServiceDesc{
	ServiceName: "kv.Group",
	HandlerType: (*GroupServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "PutAppend",
			Handler:    _Group_PutAppend_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _Group_Get_Handler,
		},
		{
			MethodName: "ClearShard",
			Handler:    _Group_ClearShard_Handler,
		},
		{
			MethodName: "TransferShard",
			Handler:    _Group_TransferShard_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "group.proto",
}