api.pb.go

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

/*
Package proto is a generated protocol buffer package.

It is generated from these files:
	api.proto

It has these top-level messages:
	PainUpdate
	GetEventsRequest
	Event
*/
package proto

import proto1 "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import google_protobuf "github.com/golang/protobuf/ptypes/empty"
import google_protobuf1 "github.com/golang/protobuf/ptypes/timestamp"
import _ "google.golang.org/genproto/googleapis/api/annotations"

import (
	context "golang.org/x/net/context"
	grpc "google.golang.org/grpc"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.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 _ = proto1.ProtoPackageIsVersion2 // please upgrade the proto package

type PainLevel int32

const (
	PainLevel_NO_PAIN     PainLevel = 0
	PainLevel_SIGNIFICANT PainLevel = 1
	PainLevel_SEVERE      PainLevel = 2
)

var PainLevel_name = map[int32]string{
	0: "NO_PAIN",
	1: "SIGNIFICANT",
	2: "SEVERE",
}
var PainLevel_value = map[string]int32{
	"NO_PAIN":     0,
	"SIGNIFICANT": 1,
	"SEVERE":      2,
}

func (x PainLevel) String() string {
	return proto1.EnumName(PainLevel_name, int32(x))
}
func (PainLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

type PainUpdate struct {
	PainLevel  PainLevel `protobuf:"varint,1,opt,name=pain_level,json=painLevel,enum=PainLevel" json:"pain_level,omitempty"`
	Passphrase string    `protobuf:"bytes,2,opt,name=passphrase" json:"passphrase,omitempty"`
}

func (m *PainUpdate) Reset()                    { *m = PainUpdate{} }
func (m *PainUpdate) String() string            { return proto1.CompactTextString(m) }
func (*PainUpdate) ProtoMessage()               {}
func (*PainUpdate) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }

func (m *PainUpdate) GetPainLevel() PainLevel {
	if m != nil {
		return m.PainLevel
	}
	return PainLevel_NO_PAIN
}

func (m *PainUpdate) GetPassphrase() string {
	if m != nil {
		return m.Passphrase
	}
	return ""
}

type GetEventsRequest struct {
	Start *google_protobuf1.Timestamp `protobuf:"bytes,1,opt,name=start" json:"start,omitempty"`
	End   *google_protobuf1.Timestamp `protobuf:"bytes,2,opt,name=end" json:"end,omitempty"`
}

func (m *GetEventsRequest) Reset()                    { *m = GetEventsRequest{} }
func (m *GetEventsRequest) String() string            { return proto1.CompactTextString(m) }
func (*GetEventsRequest) ProtoMessage()               {}
func (*GetEventsRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }

func (m *GetEventsRequest) GetStart() *google_protobuf1.Timestamp {
	if m != nil {
		return m.Start
	}
	return nil
}

func (m *GetEventsRequest) GetEnd() *google_protobuf1.Timestamp {
	if m != nil {
		return m.End
	}
	return nil
}

type Event struct {
	Timestamp *google_protobuf1.Timestamp `protobuf:"bytes,1,opt,name=timestamp" json:"timestamp,omitempty"`
	PainLevel PainLevel                   `protobuf:"varint,2,opt,name=pain_level,json=painLevel,enum=PainLevel" json:"pain_level,omitempty"`
}

func (m *Event) Reset()                    { *m = Event{} }
func (m *Event) String() string            { return proto1.CompactTextString(m) }
func (*Event) ProtoMessage()               {}
func (*Event) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} }

func (m *Event) GetTimestamp() *google_protobuf1.Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *Event) GetPainLevel() PainLevel {
	if m != nil {
		return m.PainLevel
	}
	return PainLevel_NO_PAIN
}

func init() {
	proto1.RegisterType((*PainUpdate)(nil), "PainUpdate")
	proto1.RegisterType((*GetEventsRequest)(nil), "GetEventsRequest")
	proto1.RegisterType((*Event)(nil), "Event")
	proto1.RegisterEnum("PainLevel", PainLevel_name, PainLevel_value)
}

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

// Client API for PainTracker service

type PainTrackerClient interface {
	SetPainLevel(ctx context.Context, in *PainUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
}

type painTrackerClient struct {
	cc *grpc.ClientConn
}

func NewPainTrackerClient(cc *grpc.ClientConn) PainTrackerClient {
	return &painTrackerClient{cc}
}

func (c *painTrackerClient) SetPainLevel(ctx context.Context, in *PainUpdate, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
	out := new(google_protobuf.Empty)
	err := grpc.Invoke(ctx, "/PainTracker/SetPainLevel", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for PainTracker service

type PainTrackerServer interface {
	SetPainLevel(context.Context, *PainUpdate) (*google_protobuf.Empty, error)
}

func RegisterPainTrackerServer(s *grpc.Server, srv PainTrackerServer) {
	s.RegisterService(&_PainTracker_serviceDesc, srv)
}

func _PainTracker_SetPainLevel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PainUpdate)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(PainTrackerServer).SetPainLevel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/PainTracker/SetPainLevel",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(PainTrackerServer).SetPainLevel(ctx, req.(*PainUpdate))
	}
	return interceptor(ctx, in, info, handler)
}

var _PainTracker_serviceDesc = grpc.ServiceDesc{
	ServiceName: "PainTracker",
	HandlerType: (*PainTrackerServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "SetPainLevel",
			Handler:    _PainTracker_SetPainLevel_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api.proto",
}

// Client API for Monitor service

type MonitorClient interface {
	GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (Monitor_GetEventsClient, error)
}

type monitorClient struct {
	cc *grpc.ClientConn
}

func NewMonitorClient(cc *grpc.ClientConn) MonitorClient {
	return &monitorClient{cc}
}

func (c *monitorClient) GetEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (Monitor_GetEventsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Monitor_serviceDesc.Streams[0], c.cc, "/Monitor/GetEvents", opts...)
	if err != nil {
		return nil, err
	}
	x := &monitorGetEventsClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type Monitor_GetEventsClient interface {
	Recv() (*Event, error)
	grpc.ClientStream
}

type monitorGetEventsClient struct {
	grpc.ClientStream
}

func (x *monitorGetEventsClient) Recv() (*Event, error) {
	m := new(Event)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// Server API for Monitor service

type MonitorServer interface {
	GetEvents(*GetEventsRequest, Monitor_GetEventsServer) error
}

func RegisterMonitorServer(s *grpc.Server, srv MonitorServer) {
	s.RegisterService(&_Monitor_serviceDesc, srv)
}

func _Monitor_GetEvents_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(GetEventsRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MonitorServer).GetEvents(m, &monitorGetEventsServer{stream})
}

type Monitor_GetEventsServer interface {
	Send(*Event) error
	grpc.ServerStream
}

type monitorGetEventsServer struct {
	grpc.ServerStream
}

func (x *monitorGetEventsServer) Send(m *Event) error {
	return x.ServerStream.SendMsg(m)
}

var _Monitor_serviceDesc = grpc.ServiceDesc{
	ServiceName: "Monitor",
	HandlerType: (*MonitorServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetEvents",
			Handler:       _Monitor_GetEvents_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "api.proto",
}

func init() { proto1.RegisterFile("api.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 424 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x92, 0xd1, 0x6e, 0xd3, 0x30,
	0x14, 0x86, 0x49, 0xd1, 0x3a, 0xe5, 0x74, 0x1a, 0x9d, 0x91, 0x60, 0x14, 0x04, 0x53, 0xae, 0x46,
	0xc5, 0x9c, 0x51, 0x34, 0x81, 0x76, 0x37, 0xa6, 0x30, 0x55, 0x1a, 0x61, 0x4a, 0x0b, 0x48, 0x70,
	0x31, 0xb9, 0xad, 0x69, 0x0c, 0x89, 0x6d, 0xec, 0xd3, 0x4a, 0xdc, 0xf2, 0x0a, 0x3c, 0x1a, 0xaf,
	0xc0, 0x83, 0x20, 0x3b, 0x49, 0x37, 0x15, 0x69, 0xe2, 0x2a, 0xf1, 0x39, 0x5f, 0xfe, 0xf3, 0xe7,
	0xfc, 0x86, 0x90, 0x69, 0x41, 0xb5, 0x51, 0xa8, 0x7a, 0x0f, 0xe7, 0x4a, 0xcd, 0x0b, 0x1e, 0xfb,
	0xd3, 0x64, 0xf1, 0x25, 0xe6, 0xa5, 0xc6, 0x1f, 0x75, 0xf3, 0xc9, 0x7a, 0x13, 0x45, 0xc9, 0x2d,
	0xb2, 0x52, 0xd7, 0xc0, 0xa3, 0x1a, 0x60, 0x5a, 0xc4, 0x4c, 0x4a, 0x85, 0x0c, 0x85, 0x92, 0xb6,
	0xea, 0x46, 0x1f, 0x01, 0x2e, 0x98, 0x90, 0xef, 0xf5, 0x8c, 0x21, 0x27, 0x4f, 0x01, 0x34, 0x13,
	0xf2, 0xb2, 0xe0, 0x4b, 0x5e, 0xec, 0x06, 0x7b, 0xc1, 0xfe, 0xf6, 0x00, 0xa8, 0x03, 0xce, 0x5d,
	0x25, 0x0b, 0x75, 0xf3, 0x4a, 0x1e, 0x3b, 0xd4, 0x5a, 0x9d, 0x1b, 0x66, 0xf9, 0x6e, 0x6b, 0x2f,
	0xd8, 0x0f, 0xb3, 0x6b, 0x95, 0xc8, 0x40, 0xf7, 0x8c, 0x63, 0xb2, 0xe4, 0x12, 0x6d, 0xc6, 0xbf,
	0x2f, 0xb8, 0x45, 0x72, 0x08, 0x1b, 0x16, 0x99, 0x41, 0xaf, 0xdc, 0x19, 0xf4, 0x68, 0x65, 0x8d,
	0x36, 0xde, 0xe9, 0xb8, 0xf1, 0x9e, 0x55, 0x20, 0x79, 0x06, 0xb7, 0xb9, 0x9c, 0x79, 0xf9, 0x9b,
	0x79, 0x87, 0x45, 0x05, 0x6c, 0xf8, 0x81, 0xe4, 0x15, 0x84, 0xab, 0x35, 0xfc, 0xc7, 0xb0, 0x2b,
	0x78, 0x6d, 0x03, 0xad, 0x1b, 0x36, 0xd0, 0x3f, 0x82, 0x70, 0x55, 0x27, 0x1d, 0xd8, 0x4c, 0xdf,
	0x5d, 0x5e, 0x9c, 0x0c, 0xd3, 0xee, 0x2d, 0x72, 0x07, 0x3a, 0xa3, 0xe1, 0x59, 0x3a, 0x7c, 0x33,
	0x3c, 0x3d, 0x49, 0xc7, 0xdd, 0x80, 0x00, 0xb4, 0x47, 0xc9, 0x87, 0x24, 0x4b, 0xba, 0xad, 0xc1,
	0x67, 0xe8, 0xb8, 0xcf, 0xc6, 0x86, 0x4d, 0xbf, 0x71, 0x43, 0xce, 0x61, 0x6b, 0xc4, 0xf1, 0x9a,
	0x10, 0xbd, 0xca, 0xa3, 0x77, 0xef, 0x1f, 0xd3, 0x89, 0x8b, 0x3e, 0xba, 0xff, 0xf3, 0xf7, 0x9f,
	0x5f, 0xad, 0x9d, 0x68, 0xcb, 0xa7, 0xba, 0x7c, 0x1e, 0x3b, 0x57, 0xc7, 0x41, 0x7f, 0x90, 0xc2,
	0xe6, 0x5b, 0x25, 0x05, 0x2a, 0x43, 0x4e, 0x21, 0x5c, 0x05, 0x40, 0x76, 0xe8, 0x7a, 0x18, 0xbd,
	0x36, 0xf5, 0xe7, 0xe8, 0x81, 0xd7, 0xba, 0x1b, 0x6d, 0x37, 0x5a, 0xdc, 0x63, 0xc7, 0x41, 0xff,
	0x30, 0x78, 0xfd, 0xf2, 0xd3, 0xd1, 0x5c, 0x60, 0xbe, 0x98, 0xd0, 0xa9, 0x2a, 0xe3, 0xaf, 0x2a,
	0x67, 0x72, 0x62, 0x98, 0x9c, 0xe5, 0xca, 0x58, 0x8c, 0xa7, 0xb9, 0x51, 0x52, 0x4c, 0x0f, 0xdc,
	0xf4, 0x03, 0xac, 0x7e, 0xa8, 0xbe, 0x88, 0x6d, 0xff, 0x78, 0xf1, 0x37, 0x00, 0x00, 0xff, 0xff,
	0x36, 0xdd, 0xf4, 0x54, 0xc7, 0x02, 0x00, 0x00,
}