event_state.pb.go

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

package event_state

import (
	context "context"
	fmt "fmt"
	math "math"

	proto "github.com/golang/protobuf/proto"
	timestamp "github.com/golang/protobuf/ptypes/timestamp"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

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

const (
	EventsRecord_UNKNOWN  EventsRecord_Type = 0
	EventsRecord_SENT     EventsRecord_Type = 1
	EventsRecord_ACCEPTED EventsRecord_Type = 2
	EventsRecord_RECEIVED EventsRecord_Type = 3
)

var EventsRecord_Type_name = map[int32]string{
	0: "UNKNOWN",
	1: "SENT",
	2: "ACCEPTED",
	3: "RECEIVED",
}

var EventsRecord_Type_value = map[string]int32{
	"UNKNOWN":  0,
	"SENT":     1,
	"ACCEPTED": 2,
	"RECEIVED": 3,
}

func (x EventsRecord_Type) String() string {
	return proto.EnumName(EventsRecord_Type_name, int32(x))
}

func (EventsRecord_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_de3fba9d879b76ae, []int{0, 0}
}

type EventsRecord struct {
	Events               map[string]*timestamp.Timestamp `protobuf:"bytes,1,rep,name=Events,proto3" json:"Events,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Type                 EventsRecord_Type               `protobuf:"varint,2,opt,name=type,proto3,enum=event_state.EventsRecord_Type" json:"type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                        `json:"-"`
	XXX_unrecognized     []byte                          `json:"-"`
	XXX_sizecache        int32                           `json:"-"`
}

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

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

var xxx_messageInfo_EventsRecord proto.InternalMessageInfo

func (m *EventsRecord) GetEvents() map[string]*timestamp.Timestamp {
	if m != nil {
		return m.Events
	}
	return nil
}

func (m *EventsRecord) GetType() EventsRecord_Type {
	if m != nil {
		return m.Type
	}
	return EventsRecord_UNKNOWN
}

type EventsRecordList struct {
	Items                []*EventsRecord `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

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

var xxx_messageInfo_EventsRecordList proto.InternalMessageInfo

func (m *EventsRecordList) GetItems() []*EventsRecord {
	if m != nil {
		return m.Items
	}
	return nil
}

type RecordReply struct {
	Count                uint32   `protobuf:"varint,1,opt,name=count,proto3" json:"count,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

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

var xxx_messageInfo_RecordReply proto.InternalMessageInfo

func (m *RecordReply) GetCount() uint32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func init() {
	proto.RegisterEnum("event_state.EventsRecord_Type", EventsRecord_Type_name, EventsRecord_Type_value)
	proto.RegisterType((*EventsRecord)(nil), "event_state.EventsRecord")
	proto.RegisterMapType((map[string]*timestamp.Timestamp)(nil), "event_state.EventsRecord.EventsEntry")
	proto.RegisterType((*EventsRecordList)(nil), "event_state.EventsRecordList")
	proto.RegisterType((*RecordReply)(nil), "event_state.RecordReply")
}

func init() { proto.RegisterFile("event_state.proto", fileDescriptor_de3fba9d879b76ae) }

var fileDescriptor_de3fba9d879b76ae = []byte{
	// 328 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x74, 0x50, 0x4f, 0x4b, 0xfb, 0x40,
	0x10, 0x6d, 0xd2, 0x3f, 0xbf, 0xfe, 0x66, 0x6b, 0x59, 0x17, 0x0f, 0x31, 0xa0, 0x96, 0x88, 0xd0,
	0x53, 0x2a, 0xf1, 0xa2, 0x82, 0x07, 0x49, 0xf7, 0x50, 0x94, 0x28, 0x6b, 0xaa, 0x07, 0x0f, 0xd2,
	0xd6, 0xb1, 0x14, 0xdb, 0x6e, 0x48, 0xb6, 0x85, 0x7c, 0x0e, 0xbf, 0xb0, 0x24, 0x9b, 0xc2, 0x7a,
	0xe8, 0x6d, 0xde, 0xcc, 0x7b, 0xf3, 0xe6, 0x0d, 0x1c, 0xe2, 0x16, 0xd7, 0xea, 0x23, 0x53, 0x13,
	0x85, 0x7e, 0x92, 0x4a, 0x25, 0x19, 0x31, 0x5a, 0xee, 0xd9, 0x5c, 0xca, 0xf9, 0x12, 0x07, 0xe5,
	0x68, 0xba, 0xf9, 0x1a, 0xa8, 0xc5, 0x0a, 0x33, 0x35, 0x59, 0x25, 0x9a, 0xed, 0xfd, 0xd8, 0xd0,
	0xe1, 0x85, 0x20, 0x13, 0x38, 0x93, 0xe9, 0x27, 0xbb, 0x83, 0x96, 0xc6, 0x8e, 0xd5, 0xab, 0xf7,
	0x49, 0x70, 0xe1, 0x9b, 0x16, 0x26, 0xb5, 0x02, 0x7c, 0xad, 0xd2, 0x5c, 0x54, 0x22, 0x16, 0x40,
	0x43, 0xe5, 0x09, 0x3a, 0x76, 0xcf, 0xea, 0x77, 0x83, 0xd3, 0xfd, 0xe2, 0x38, 0x4f, 0x50, 0x94,
	0x5c, 0x77, 0x0c, 0xc4, 0x58, 0xc5, 0x28, 0xd4, 0xbf, 0x31, 0x77, 0xac, 0x9e, 0xd5, 0xff, 0x2f,
	0x8a, 0x92, 0x5d, 0x42, 0x73, 0x3b, 0x59, 0x6e, 0xf4, 0x56, 0x12, 0xb8, 0xbe, 0x4e, 0xe5, 0xef,
	0x52, 0xf9, 0xf1, 0x2e, 0x95, 0xd0, 0xc4, 0x5b, 0xfb, 0xda, 0xf2, 0x6e, 0xa0, 0x51, 0x98, 0x30,
	0x02, 0xff, 0xc6, 0xd1, 0x43, 0xf4, 0xf4, 0x16, 0xd1, 0x1a, 0x6b, 0x43, 0xe3, 0x85, 0x47, 0x31,
	0xb5, 0x58, 0x07, 0xda, 0xf7, 0x61, 0xc8, 0x9f, 0x63, 0x3e, 0xa4, 0x76, 0x81, 0x04, 0x0f, 0xf9,
	0xe8, 0x95, 0x0f, 0x69, 0xdd, 0x0b, 0x81, 0x9a, 0xc7, 0x3e, 0x2e, 0x32, 0xc5, 0x06, 0xd0, 0x5c,
	0x28, 0x5c, 0xed, 0xfe, 0x72, 0xbc, 0x37, 0x9a, 0xd0, 0x3c, 0xef, 0x1c, 0x48, 0xd5, 0xc0, 0x64,
	0x99, 0xb3, 0x23, 0x68, 0xce, 0xe4, 0x66, 0xad, 0xca, 0x60, 0x07, 0x42, 0x83, 0xe0, 0x1d, 0xba,
	0xa6, 0x16, 0x53, 0x36, 0x82, 0x8e, 0xae, 0xab, 0x8f, 0x9e, 0xec, 0x35, 0x2a, 0xce, 0x72, 0x9d,
	0x3f, 0x63, 0xc3, 0xd0, 0xab, 0x4d, 0x5b, 0xe5, 0x83, 0xae, 0x7e, 0x03, 0x00, 0x00, 0xff, 0xff,
	0x1f, 0xfa, 0x30, 0x3b, 0x26, 0x02, 0x00, 0x00,
}

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

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

// EventsRecorderClient is the client API for EventsRecorder service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type EventsRecorderClient interface {
	RecordEvents(ctx context.Context, in *EventsRecordList, opts ...grpc.CallOption) (*RecordReply, error)
}

type eventsRecorderClient struct {
	cc *grpc.ClientConn
}

func NewEventsRecorderClient(cc *grpc.ClientConn) EventsRecorderClient {
	return &eventsRecorderClient{cc}
}

func (c *eventsRecorderClient) RecordEvents(ctx context.Context, in *EventsRecordList, opts ...grpc.CallOption) (*RecordReply, error) {
	out := new(RecordReply)
	err := c.cc.Invoke(ctx, "/event_state.EventsRecorder/RecordEvents", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// EventsRecorderServer is the server API for EventsRecorder service.
type EventsRecorderServer interface {
	RecordEvents(context.Context, *EventsRecordList) (*RecordReply, error)
}

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

func (*UnimplementedEventsRecorderServer) RecordEvents(ctx context.Context, req *EventsRecordList) (*RecordReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RecordEvents not implemented")
}

func RegisterEventsRecorderServer(s *grpc.Server, srv EventsRecorderServer) {
	s.RegisterService(&_EventsRecorder_serviceDesc, srv)
}

func _EventsRecorder_RecordEvents_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EventsRecordList)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(EventsRecorderServer).RecordEvents(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/event_state.EventsRecorder/RecordEvents",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(EventsRecorderServer).RecordEvents(ctx, req.(*EventsRecordList))
	}
	return interceptor(ctx, in, info, handler)
}

var _EventsRecorder_serviceDesc = grpc.ServiceDesc{
	ServiceName: "event_state.EventsRecorder",
	HandlerType: (*EventsRecorderServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RecordEvents",
			Handler:    _EventsRecorder_RecordEvents_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "event_state.proto",
}