// Code generated by protoc-gen-gogo. DO NOT EDIT.

// source: protos/occ.proto

package pb

import proto "github.com/golang/protobuf/proto"

import fmt "fmt"

import math "math"

import (

context "golang.org/x/net/context"

grpc "google.golang.org/grpc"

)

import io "io"

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

type StateChangeTrigger int32

const (

StateChangeTrigger_EXECUTOR StateChangeTrigger = 0

StateChangeTrigger_DEVICE_INTENTIONAL StateChangeTrigger = 1

StateChangeTrigger_DEVICE_ERROR StateChangeTrigger = 2

)

var StateChangeTrigger_name = map[int32]string{

0: "EXECUTOR",

1: "DEVICE_INTENTIONAL",

2: "DEVICE_ERROR",

}

var StateChangeTrigger_value = map[string]int32{

"EXECUTOR": 0,

"DEVICE_INTENTIONAL": 1,

"DEVICE_ERROR": 2,

}

func (x StateChangeTrigger) String() string {

return proto.EnumName(StateChangeTrigger_name, int32(x))

}

func (StateChangeTrigger) EnumDescriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{0}

}

type StateType int32

const (

StateType_STATE_STABLE StateType = 0

StateType_STATE_INTERMEDIATE StateType = 1

)

var StateType_name = map[int32]string{

0: "STATE_STABLE",

1: "STATE_INTERMEDIATE",

}

var StateType_value = map[string]int32{

"STATE_STABLE": 0,

"STATE_INTERMEDIATE": 1,

}

func (x StateType) String() string {

return proto.EnumName(StateType_name, int32(x))

}

func (StateType) EnumDescriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{1}

}

type DeviceEventType int32

const (

DeviceEventType_NULL_DEVICE_EVENT DeviceEventType = 0

DeviceEventType_END_OF_DATA DeviceEventType = 1

)

var DeviceEventType_name = map[int32]string{

0: "NULL_DEVICE_EVENT",

1: "END_OF_DATA",

}

var DeviceEventType_value = map[string]int32{

"NULL_DEVICE_EVENT": 0,

"END_OF_DATA": 1,

}

func (x DeviceEventType) String() string {

return proto.EnumName(DeviceEventType_name, int32(x))

}

func (DeviceEventType) EnumDescriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{2}

}

type StateStreamRequest struct {

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *StateStreamRequest) Reset() { *m = StateStreamRequest{} }

func (m *StateStreamRequest) String() string { return proto.CompactTextString(m) }

func (*StateStreamRequest) ProtoMessage() {}

func (*StateStreamRequest) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{0}

}

func (m *StateStreamRequest) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *StateStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_StateStreamRequest.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *StateStreamRequest) XXX_Merge(src proto.Message) {

xxx_messageInfo_StateStreamRequest.Merge(dst, src)

}

func (m *StateStreamRequest) XXX_Size() int {

return m.Size()

}

func (m *StateStreamRequest) XXX_DiscardUnknown() {

xxx_messageInfo_StateStreamRequest.DiscardUnknown(m)

}

var xxx_messageInfo_StateStreamRequest proto.InternalMessageInfo

type StateStreamReply struct {

Type StateType `protobuf:"varint,1,opt,name=type,proto3,enum=occ_pb.StateType" json:"type,omitempty"`

State string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *StateStreamReply) Reset() { *m = StateStreamReply{} }

func (m *StateStreamReply) String() string { return proto.CompactTextString(m) }

func (*StateStreamReply) ProtoMessage() {}

func (*StateStreamReply) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{1}

}

func (m *StateStreamReply) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *StateStreamReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_StateStreamReply.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *StateStreamReply) XXX_Merge(src proto.Message) {

xxx_messageInfo_StateStreamReply.Merge(dst, src)

}

func (m *StateStreamReply) XXX_Size() int {

return m.Size()

}

func (m *StateStreamReply) XXX_DiscardUnknown() {

xxx_messageInfo_StateStreamReply.DiscardUnknown(m)

}

var xxx_messageInfo_StateStreamReply proto.InternalMessageInfo

func (m *StateStreamReply) GetType() StateType {

if m != nil {

return m.Type

}

return StateType_STATE_STABLE

}

func (m *StateStreamReply) GetState() string {

if m != nil {

return m.State

}

return ""

}

type EventStreamRequest struct {

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *EventStreamRequest) Reset() { *m = EventStreamRequest{} }

func (m *EventStreamRequest) String() string { return proto.CompactTextString(m) }

func (*EventStreamRequest) ProtoMessage() {}

func (*EventStreamRequest) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{2}

}

func (m *EventStreamRequest) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *EventStreamRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_EventStreamRequest.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *EventStreamRequest) XXX_Merge(src proto.Message) {

xxx_messageInfo_EventStreamRequest.Merge(dst, src)

}

func (m *EventStreamRequest) XXX_Size() int {

return m.Size()

}

func (m *EventStreamRequest) XXX_DiscardUnknown() {

xxx_messageInfo_EventStreamRequest.DiscardUnknown(m)

}

var xxx_messageInfo_EventStreamRequest proto.InternalMessageInfo

type DeviceEvent struct {

Type DeviceEventType `protobuf:"varint,1,opt,name=type,proto3,enum=occ_pb.DeviceEventType" json:"type,omitempty"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *DeviceEvent) Reset() { *m = DeviceEvent{} }

func (m *DeviceEvent) String() string { return proto.CompactTextString(m) }

func (*DeviceEvent) ProtoMessage() {}

func (*DeviceEvent) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{3}

}

func (m *DeviceEvent) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *DeviceEvent) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_DeviceEvent.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *DeviceEvent) XXX_Merge(src proto.Message) {

xxx_messageInfo_DeviceEvent.Merge(dst, src)

}

func (m *DeviceEvent) XXX_Size() int {

return m.Size()

}

func (m *DeviceEvent) XXX_DiscardUnknown() {

xxx_messageInfo_DeviceEvent.DiscardUnknown(m)

}

var xxx_messageInfo_DeviceEvent proto.InternalMessageInfo

func (m *DeviceEvent) GetType() DeviceEventType {

if m != nil {

return m.Type

}

return DeviceEventType_NULL_DEVICE_EVENT

}

type EventStreamReply struct {

Event *DeviceEvent `protobuf:"bytes,1,opt,name=event,proto3" json:"event,omitempty"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *EventStreamReply) Reset() { *m = EventStreamReply{} }

func (m *EventStreamReply) String() string { return proto.CompactTextString(m) }

func (*EventStreamReply) ProtoMessage() {}

func (*EventStreamReply) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{4}

}

func (m *EventStreamReply) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *EventStreamReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_EventStreamReply.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *EventStreamReply) XXX_Merge(src proto.Message) {

xxx_messageInfo_EventStreamReply.Merge(dst, src)

}

func (m *EventStreamReply) XXX_Size() int {

return m.Size()

}

func (m *EventStreamReply) XXX_DiscardUnknown() {

xxx_messageInfo_EventStreamReply.DiscardUnknown(m)

}

var xxx_messageInfo_EventStreamReply proto.InternalMessageInfo

func (m *EventStreamReply) GetEvent() *DeviceEvent {

if m != nil {

return m.Event

}

return nil

}

type GetStateRequest struct {

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *GetStateRequest) Reset() { *m = GetStateRequest{} }

func (m *GetStateRequest) String() string { return proto.CompactTextString(m) }

func (*GetStateRequest) ProtoMessage() {}

func (*GetStateRequest) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{5}

}

func (m *GetStateRequest) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *GetStateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_GetStateRequest.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *GetStateRequest) XXX_Merge(src proto.Message) {

xxx_messageInfo_GetStateRequest.Merge(dst, src)

}

func (m *GetStateRequest) XXX_Size() int {

return m.Size()

}

func (m *GetStateRequest) XXX_DiscardUnknown() {

xxx_messageInfo_GetStateRequest.DiscardUnknown(m)

}

var xxx_messageInfo_GetStateRequest proto.InternalMessageInfo

type GetStateReply struct {

State string `protobuf:"bytes,1,opt,name=state,proto3" json:"state,omitempty"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *GetStateReply) Reset() { *m = GetStateReply{} }

func (m *GetStateReply) String() string { return proto.CompactTextString(m) }

func (*GetStateReply) ProtoMessage() {}

func (*GetStateReply) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{6}

}

func (m *GetStateReply) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *GetStateReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_GetStateReply.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *GetStateReply) XXX_Merge(src proto.Message) {

xxx_messageInfo_GetStateReply.Merge(dst, src)

}

func (m *GetStateReply) XXX_Size() int {

return m.Size()

}

func (m *GetStateReply) XXX_DiscardUnknown() {

xxx_messageInfo_GetStateReply.DiscardUnknown(m)

}

var xxx_messageInfo_GetStateReply proto.InternalMessageInfo

func (m *GetStateReply) GetState() string {

if m != nil {

return m.State

}

return ""

}

type ConfigEntry 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"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *ConfigEntry) Reset() { *m = ConfigEntry{} }

func (m *ConfigEntry) String() string { return proto.CompactTextString(m) }

func (*ConfigEntry) ProtoMessage() {}

func (*ConfigEntry) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{7}

}

func (m *ConfigEntry) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *ConfigEntry) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_ConfigEntry.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *ConfigEntry) XXX_Merge(src proto.Message) {

xxx_messageInfo_ConfigEntry.Merge(dst, src)

}

func (m *ConfigEntry) XXX_Size() int {

return m.Size()

}

func (m *ConfigEntry) XXX_DiscardUnknown() {

xxx_messageInfo_ConfigEntry.DiscardUnknown(m)

}

var xxx_messageInfo_ConfigEntry proto.InternalMessageInfo

func (m *ConfigEntry) GetKey() string {

if m != nil {

return m.Key

}

return ""

}

func (m *ConfigEntry) GetValue() string {

if m != nil {

return m.Value

}

return ""

}

type TransitionRequest struct {

SrcState string `protobuf:"bytes,1,opt,name=srcState,proto3" json:"srcState,omitempty"`

TransitionEvent string `protobuf:"bytes,2,opt,name=transitionEvent,proto3" json:"transitionEvent,omitempty"`

Arguments []*ConfigEntry `protobuf:"bytes,3,rep,name=arguments,proto3" json:"arguments,omitempty"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *TransitionRequest) Reset() { *m = TransitionRequest{} }

func (m *TransitionRequest) String() string { return proto.CompactTextString(m) }

func (*TransitionRequest) ProtoMessage() {}

func (*TransitionRequest) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{8}

}

func (m *TransitionRequest) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *TransitionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_TransitionRequest.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *TransitionRequest) XXX_Merge(src proto.Message) {

xxx_messageInfo_TransitionRequest.Merge(dst, src)

}

func (m *TransitionRequest) XXX_Size() int {

return m.Size()

}

func (m *TransitionRequest) XXX_DiscardUnknown() {

xxx_messageInfo_TransitionRequest.DiscardUnknown(m)

}

var xxx_messageInfo_TransitionRequest proto.InternalMessageInfo

func (m *TransitionRequest) GetSrcState() string {

if m != nil {

return m.SrcState

}

return ""

}

func (m *TransitionRequest) GetTransitionEvent() string {

if m != nil {

return m.TransitionEvent

}

return ""

}

func (m *TransitionRequest) GetArguments() []*ConfigEntry {

if m != nil {

return m.Arguments

}

return nil

}

type TransitionReply struct {

Trigger StateChangeTrigger `protobuf:"varint,1,opt,name=trigger,proto3,enum=occ_pb.StateChangeTrigger" json:"trigger,omitempty"`

State string `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"`

TransitionEvent string `protobuf:"bytes,3,opt,name=transitionEvent,proto3" json:"transitionEvent,omitempty"`

Ok bool `protobuf:"varint,4,opt,name=ok,proto3" json:"ok,omitempty"`

XXX_NoUnkeyedLiteral struct{} `json:"-"`

XXX_unrecognized []byte `json:"-"`

XXX_sizecache int32 `json:"-"`

}

func (m *TransitionReply) Reset() { *m = TransitionReply{} }

func (m *TransitionReply) String() string { return proto.CompactTextString(m) }

func (*TransitionReply) ProtoMessage() {}

func (*TransitionReply) Descriptor() ([]byte, []int) {

return fileDescriptor_occ_1f915b2e44fd7e91, []int{9}

}

func (m *TransitionReply) XXX_Unmarshal(b []byte) error {

return m.Unmarshal(b)

}

func (m *TransitionReply) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {

if deterministic {

return xxx_messageInfo_TransitionReply.Marshal(b, m, deterministic)

} else {

b = b[:cap(b)]

n, err := m.MarshalTo(b)

if err != nil {

return nil, err

}

return b[:n], nil

}

}

func (dst *TransitionReply) XXX_Merge(src proto.Message) {

xxx_messageInfo_TransitionReply.Merge(dst, src)

}

func (m *TransitionReply) XXX_Size() int {

return m.Size()

}

func (m *TransitionReply) XXX_DiscardUnknown() {

xxx_messageInfo_TransitionReply.DiscardUnknown(m)

}

var xxx_messageInfo_TransitionReply proto.InternalMessageInfo

func (m *TransitionReply) GetTrigger() StateChangeTrigger {

if m != nil {

return m.Trigger

}

return StateChangeTrigger_EXECUTOR

}

func (m *TransitionReply) GetState() string {

if m != nil {

return m.State

}

return ""

}

func (m *TransitionReply) GetTransitionEvent() string {

if m != nil {

return m.TransitionEvent

}

return ""

}

func (m *TransitionReply) GetOk() bool {

if m != nil {

return m.Ok

}

return false

}

func init() {

proto.RegisterType((*StateStreamRequest)(nil), "occ_pb.StateStreamRequest")

proto.RegisterType((*StateStreamReply)(nil), "occ_pb.StateStreamReply")

proto.RegisterType((*EventStreamRequest)(nil), "occ_pb.EventStreamRequest")

proto.RegisterType((*DeviceEvent)(nil), "occ_pb.DeviceEvent")

proto.RegisterType((*EventStreamReply)(nil), "occ_pb.EventStreamReply")

proto.RegisterType((*GetStateRequest)(nil), "occ_pb.GetStateRequest")

proto.RegisterType((*GetStateReply)(nil), "occ_pb.GetStateReply")

proto.RegisterType((*ConfigEntry)(nil), "occ_pb.ConfigEntry")

proto.RegisterType((*TransitionRequest)(nil), "occ_pb.TransitionRequest")

proto.RegisterType((*TransitionReply)(nil), "occ_pb.TransitionReply")

proto.RegisterEnum("occ_pb.StateChangeTrigger", StateChangeTrigger_name, StateChangeTrigger_value)

proto.RegisterEnum("occ_pb.StateType", StateType_name, StateType_value)

proto.RegisterEnum("occ_pb.DeviceEventType", DeviceEventType_name, DeviceEventType_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

// OccClient is the client API for Occ service.

//

// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.

type OccClient interface {

// We have to have a notification stream because the FairMQDevice might transition

// on its own for whatever reason.

EventStream(ctx context.Context, in *EventStreamRequest, opts ...grpc.CallOption) (Occ_EventStreamClient, error)

StateStream(ctx context.Context, in *StateStreamRequest, opts ...grpc.CallOption) (Occ_StateStreamClient, error)

GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateReply, error)

Transition(ctx context.Context, in *TransitionRequest, opts ...grpc.CallOption) (*TransitionReply, error)

}

type occClient struct {

cc *grpc.ClientConn

}

func NewOccClient(cc *grpc.ClientConn) OccClient {

return &occClient{cc}

}

func (c *occClient) EventStream(ctx context.Context, in *EventStreamRequest, opts ...grpc.CallOption) (Occ_EventStreamClient, error) {

stream, err := c.cc.NewStream(ctx, &_Occ_serviceDesc.Streams[0], "/occ_pb.Occ/EventStream", opts...)

if err != nil {

return nil, err

}

x := &occEventStreamClient{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 Occ_EventStreamClient interface {

Recv() (*EventStreamReply, error)

grpc.ClientStream

}

type occEventStreamClient struct {

grpc.ClientStream

}

func (x *occEventStreamClient) Recv() (*EventStreamReply, error) {

m := new(EventStreamReply)

if err := x.ClientStream.RecvMsg(m); err != nil {

return nil, err

}

return m, nil

}

func (c *occClient) StateStream(ctx context.Context, in *StateStreamRequest, opts ...grpc.CallOption) (Occ_StateStreamClient, error) {

stream, err := c.cc.NewStream(ctx, &_Occ_serviceDesc.Streams[1], "/occ_pb.Occ/StateStream", opts...)

if err != nil {

return nil, err

}

x := &occStateStreamClient{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 Occ_StateStreamClient interface {

Recv() (*StateStreamReply, error)

grpc.ClientStream

}

type occStateStreamClient struct {

grpc.ClientStream

}

func (x *occStateStreamClient) Recv() (*StateStreamReply, error) {

m := new(StateStreamReply)

if err := x.ClientStream.RecvMsg(m); err != nil {

return nil, err

}

return m, nil

}

func (c *occClient) GetState(ctx context.Context, in *GetStateRequest, opts ...grpc.CallOption) (*GetStateReply, error) {

out := new(GetStateReply)

err := c.cc.Invoke(ctx, "/occ_pb.Occ/GetState", in, out, opts...)

if err != nil {

return nil, err

}

return out, nil

}

func (c *occClient) Transition(ctx context.Context, in *TransitionRequest, opts ...grpc.CallOption) (*TransitionReply, error) {

out := new(TransitionReply)

err := c.cc.Invoke(ctx, "/occ_pb.Occ/Transition", in, out, opts...)

if err != nil {

return nil, err

}

return out, nil

}

// OccServer is the server API for Occ service.

type OccServer interface {

// We have to have a notification stream because the FairMQDevice might transition

// on its own for whatever reason.

EventStream(*EventStreamRequest, Occ_EventStreamServer) error

StateStream(*StateStreamRequest, Occ_StateStreamServer) error

GetState(context.Context, *GetStateRequest) (*GetStateReply, error)

Transition(context.Context, *TransitionRequest) (*TransitionReply, error)

}

func RegisterOccServer(s *grpc.Server, srv OccServer) {

s.RegisterService(&_Occ_serviceDesc, srv)

}

func _Occ_EventStream_Handler(srv interface{}, stream grpc.ServerStream) error {

m := new(EventStreamRequest)

if err := stream.RecvMsg(m); err != nil {

return err

}

return srv.(OccServer).EventStream(m, &occEventStreamServer{stream})

}

type Occ_EventStreamServer interface {

Send(*EventStreamReply) error

grpc.ServerStream

}

type occEventStreamServer struct {

grpc.ServerStream

}

func (x *occEventStreamServer) Send(m *EventStreamReply) error {

return x.ServerStream.SendMsg(m)

}

func _Occ_StateStream_Handler(srv interface{}, stream grpc.ServerStream) error {

m := new(StateStreamRequest)

if err := stream.RecvMsg(m); err != nil {

return err

}

return srv.(OccServer).StateStream(m, &occStateStreamServer{stream})

}

type Occ_StateStreamServer interface {

Send(*StateStreamReply) error

grpc.ServerStream

}

type occStateStreamServer struct {

grpc.ServerStream

}

func (x *occStateStreamServer) Send(m *StateStreamReply) error {

return x.ServerStream.SendMsg(m)

}

func _Occ_GetState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {

in := new(GetStateRequest)

if err := dec(in); err != nil {

return nil, err

}

if interceptor == nil {

return srv.(OccServer).GetState(ctx, in)

}

info := &grpc.UnaryServerInfo{

Server: srv,

FullMethod: "/occ_pb.Occ/GetState",

}

handler := func(ctx context.Context, req interface{}) (interface{}, error) {

return srv.(OccServer).GetState(ctx, req.(*GetStateRequest))

}

return interceptor(ctx, in, info, handler)

}

func _Occ_Transition_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {

in := new(TransitionRequest)

if err := dec(in); err != nil {

return nil, err

}

if interceptor == nil {

return srv.(OccServer).Transition(ctx, in)

}

info := &grpc.UnaryServerInfo{

Server: srv,

FullMethod: "/occ_pb.Occ/Transition",

}

handler := func(ctx context.Context, req interface{}) (interface{}, error) {

return srv.(OccServer).Transition(ctx, req.(*TransitionRequest))

}

return interceptor(ctx, in, info, handler)

}

var _Occ_serviceDesc = grpc.ServiceDesc{

ServiceName: "occ_pb.Occ",

HandlerType: (*OccServer)(nil),

Methods: []grpc.MethodDesc{

{

MethodName: "GetState",

Handler: _Occ_GetState_Handler,

},

{

MethodName: "Transition",

Handler: _Occ_Transition_Handler,

},

},

Streams: []grpc.StreamDesc{

{

StreamName: "EventStream",

Handler: _Occ_EventStream_Handler,

ServerStreams: true,

},

{

StreamName: "StateStream",

Handler: _Occ_StateStream_Handler,

ServerStreams: true,

},

},

Metadata: "protos/occ.proto",

}

func (m *StateStreamRequest) Marshal() (dAtA []byte, err error) {

size := m.Size()

dAtA = make([]byte, size)

n, err := m.MarshalTo(dAtA)

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *StateStreamRequest) MarshalTo(dAtA []byte) (int, error) {

var i int

_ = i

var l int

_ = l

if m.XXX_unrecognized != nil {

i += copy(dAtA[i:], m.XXX_unrecognized)

}

return i, nil

}

func (m *StateStreamReply) Marshal() (dAtA []byte, err error) {

size := m.Size()

dAtA = make([]byte, size)

n, err := m.MarshalTo(dAtA)

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *StateStreamReply) MarshalTo(dAtA []byte) (int, error) {

var i int

_ = i

var l int

_ = l

if m.Type != 0 {

dAtA[i] = 0x8

i++

i = encodeVarintOcc(dAtA, i, uint64(m.Type))

}

if len(m.State) > 0 {

dAtA[i] = 0x12

i++

i = encodeVarintOcc(dAtA, i, uint64(len(m.State)))

i += copy(dAtA[i:], m.State)

}

if m.XXX_unrecognized != nil {

i += copy(dAtA[i:], m.XXX_unrecognized)

}

return i, nil

}

func (m *EventStreamRequest) Marshal() (dAtA []byte, err error) {

size := m.Size()

dAtA = make([]byte, size)

n, err := m.MarshalTo(dAtA)

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *EventStreamRequest) MarshalTo(dAtA []byte) (int, error) {

var i int

_ = i

var l int

_ = l

if m.XXX_unrecognized != nil {

i += copy(dAtA[i:], m.XXX_unrecognized)

}

return i, nil

}

func (m *DeviceEvent) Marshal() (dAtA []byte, err error) {

size := m.Size()

dAtA = make([]byte, size)

n, err := m.MarshalTo(dAtA)

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *DeviceEvent) MarshalTo(dAtA []byte) (int, error) {

var i int

_ = i

var l int

_ = l

if m.Type != 0 {

dAtA[i] = 0x8

i++

i = encodeVarintOcc(dAtA, i, uint64(m.Type))

}

if m.XXX_unrecognized != nil {

i += copy(dAtA[i:], m.XXX_unrecognized)

}

return i, nil

}

func (m *EventStreamReply) Marshal() (dAtA []byte, err error) {

size := m.Size()

dAtA = make([]byte, size)

n, err := m.MarshalTo(dAtA)

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *EventStreamReply) MarshalTo(dAtA []byte) (int, error) {

var i int

_ = i

var l int

_ = l

if m.Event != nil {

dAtA[i] = 0xa

i++

i = encodeVarintOcc(dAtA, i, uint64(m.Event.Size()))

n1, err := m.Event.MarshalTo(dAtA[i:])

if err != nil {

return 0, err

}

i += n1

}

if m.XXX_unrecognized != nil {

i += copy(dAtA[i:], m.XXX_unrecognized)

}

return i, nil

}

func (m *GetStateRequest) Marshal() (dAtA []byte, err error) {

size := m.Size()

dAtA = make([]byte, size)

n, err := m.MarshalTo(dAtA)

if err != nil {

return nil, err

}

return dAtA[:n], nil

}

func (m *GetStateRequest) MarshalTo(dAtA []byte) (int, error) {

var i int

_ = i

var l int

_ = l

if m.XXX_unrecognized != nil {

i += copy(dAtA[i:], m.XXX_unrecognized)

}

return i, nil

}

func (m *GetStateReply) Marshal() (dAtA []byte, err error) {