lighter.pb.go

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

package LighterGRPC

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/grpc-ecosystem/grpc-gateway/third_party/googleapis/google/api"

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

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

type LogLevel int32

const (
	LogLevel_DEBUG LogLevel = 0
	LogLevel_INFO  LogLevel = 1
	LogLevel_WARN  LogLevel = 2
	LogLevel_ERROR LogLevel = 3
	LogLevel_PANIC LogLevel = 4
)

var LogLevel_name = map[int32]string{
	0: "DEBUG",
	1: "INFO",
	2: "WARN",
	3: "ERROR",
	4: "PANIC",
}
var LogLevel_value = map[string]int32{
	"DEBUG": 0,
	"INFO":  1,
	"WARN":  2,
	"ERROR": 3,
	"PANIC": 4,
}

func (x LogLevel) String() string {
	return proto.EnumName(LogLevel_name, int32(x))
}
func (LogLevel) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0} }

type ColorMessage struct {
	Onstate  bool   `protobuf:"varint,1,opt,name=onstate" json:"onstate,omitempty"`
	R        int32  `protobuf:"varint,2,opt,name=r" json:"r,omitempty"`
	G        int32  `protobuf:"varint,3,opt,name=g" json:"g,omitempty"`
	B        int32  `protobuf:"varint,4,opt,name=b" json:"b,omitempty"`
	Opacity  int32  `protobuf:"varint,5,opt,name=opacity" json:"opacity,omitempty"`
	DeviceID string `protobuf:"bytes,6,opt,name=deviceID" json:"deviceID,omitempty"`
	Password string `protobuf:"bytes,7,opt,name=password" json:"password,omitempty"`
}

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

type StateMessage struct {
	Onstate  bool   `protobuf:"varint,1,opt,name=onstate" json:"onstate,omitempty"`
	DeviceID string `protobuf:"bytes,2,opt,name=deviceID" json:"deviceID,omitempty"`
	Password string `protobuf:"bytes,3,opt,name=password" json:"password,omitempty"`
}

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

type ScheduledSwitch struct {
	Time     int64  `protobuf:"varint,1,opt,name=time" json:"time,omitempty"`
	Onstate  bool   `protobuf:"varint,2,opt,name=onstate" json:"onstate,omitempty"`
	DeviceID string `protobuf:"bytes,3,opt,name=deviceID" json:"deviceID,omitempty"`
	Password string `protobuf:"bytes,4,opt,name=password" json:"password,omitempty"`
}

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

type LogEntry struct {
	Time    int64  `protobuf:"varint,1,opt,name=time" json:"time,omitempty"`
	Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
}

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

type LogRequest struct {
	LogLevel LogLevel `protobuf:"varint,1,opt,name=logLevel,enum=LighterGRPC.LogLevel" json:"logLevel,omitempty"`
	Amount   int32    `protobuf:"varint,2,opt,name=amount" json:"amount,omitempty"`
	Password string   `protobuf:"bytes,3,opt,name=password" json:"password,omitempty"`
}

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

func init() {
	proto.RegisterType((*ColorMessage)(nil), "LighterGRPC.ColorMessage")
	proto.RegisterType((*StateMessage)(nil), "LighterGRPC.StateMessage")
	proto.RegisterType((*ScheduledSwitch)(nil), "LighterGRPC.ScheduledSwitch")
	proto.RegisterType((*LogEntry)(nil), "LighterGRPC.LogEntry")
	proto.RegisterType((*LogRequest)(nil), "LighterGRPC.LogRequest")
	proto.RegisterEnum("LighterGRPC.LogLevel", LogLevel_name, LogLevel_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.SupportPackageIsVersion3

// Client API for Lighter service

type LighterClient interface {
	CheckConnection(ctx context.Context, in *Request, opts ...grpc.CallOption) (Lighter_CheckConnectionClient, error)
	LoadServerLog(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (Lighter_LoadServerLogClient, error)
	ScheduleSwitchState(ctx context.Context, in *ScheduledSwitch, opts ...grpc.CallOption) (*Confirmation, error)
	SetColor(ctx context.Context, in *ColorMessage, opts ...grpc.CallOption) (*Confirmation, error)
	SwitchState(ctx context.Context, in *StateMessage, opts ...grpc.CallOption) (*Confirmation, error)
}

type lighterClient struct {
	cc *grpc.ClientConn
}

func NewLighterClient(cc *grpc.ClientConn) LighterClient {
	return &lighterClient{cc}
}

func (c *lighterClient) CheckConnection(ctx context.Context, in *Request, opts ...grpc.CallOption) (Lighter_CheckConnectionClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Lighter_serviceDesc.Streams[0], c.cc, "/LighterGRPC.Lighter/CheckConnection", opts...)
	if err != nil {
		return nil, err
	}
	x := &lighterCheckConnectionClient{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 Lighter_CheckConnectionClient interface {
	Recv() (*ColorMessage, error)
	grpc.ClientStream
}

type lighterCheckConnectionClient struct {
	grpc.ClientStream
}

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

func (c *lighterClient) LoadServerLog(ctx context.Context, in *LogRequest, opts ...grpc.CallOption) (Lighter_LoadServerLogClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_Lighter_serviceDesc.Streams[1], c.cc, "/LighterGRPC.Lighter/LoadServerLog", opts...)
	if err != nil {
		return nil, err
	}
	x := &lighterLoadServerLogClient{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 Lighter_LoadServerLogClient interface {
	Recv() (*LogEntry, error)
	grpc.ClientStream
}

type lighterLoadServerLogClient struct {
	grpc.ClientStream
}

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

func (c *lighterClient) ScheduleSwitchState(ctx context.Context, in *ScheduledSwitch, opts ...grpc.CallOption) (*Confirmation, error) {
	out := new(Confirmation)
	err := grpc.Invoke(ctx, "/LighterGRPC.Lighter/ScheduleSwitchState", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lighterClient) SetColor(ctx context.Context, in *ColorMessage, opts ...grpc.CallOption) (*Confirmation, error) {
	out := new(Confirmation)
	err := grpc.Invoke(ctx, "/LighterGRPC.Lighter/SetColor", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *lighterClient) SwitchState(ctx context.Context, in *StateMessage, opts ...grpc.CallOption) (*Confirmation, error) {
	out := new(Confirmation)
	err := grpc.Invoke(ctx, "/LighterGRPC.Lighter/SwitchState", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for Lighter service

type LighterServer interface {
	CheckConnection(*Request, Lighter_CheckConnectionServer) error
	LoadServerLog(*LogRequest, Lighter_LoadServerLogServer) error
	ScheduleSwitchState(context.Context, *ScheduledSwitch) (*Confirmation, error)
	SetColor(context.Context, *ColorMessage) (*Confirmation, error)
	SwitchState(context.Context, *StateMessage) (*Confirmation, error)
}

func RegisterLighterServer(s *grpc.Server, srv LighterServer) {
	s.RegisterService(&_Lighter_serviceDesc, srv)
}

func _Lighter_CheckConnection_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Request)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LighterServer).CheckConnection(m, &lighterCheckConnectionServer{stream})
}

type Lighter_CheckConnectionServer interface {
	Send(*ColorMessage) error
	grpc.ServerStream
}

type lighterCheckConnectionServer struct {
	grpc.ServerStream
}

func (x *lighterCheckConnectionServer) Send(m *ColorMessage) error {
	return x.ServerStream.SendMsg(m)
}

func _Lighter_LoadServerLog_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(LogRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(LighterServer).LoadServerLog(m, &lighterLoadServerLogServer{stream})
}

type Lighter_LoadServerLogServer interface {
	Send(*LogEntry) error
	grpc.ServerStream
}

type lighterLoadServerLogServer struct {
	grpc.ServerStream
}

func (x *lighterLoadServerLogServer) Send(m *LogEntry) error {
	return x.ServerStream.SendMsg(m)
}

func _Lighter_ScheduleSwitchState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ScheduledSwitch)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LighterServer).ScheduleSwitchState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/LighterGRPC.Lighter/ScheduleSwitchState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LighterServer).ScheduleSwitchState(ctx, req.(*ScheduledSwitch))
	}
	return interceptor(ctx, in, info, handler)
}

func _Lighter_SetColor_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ColorMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LighterServer).SetColor(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/LighterGRPC.Lighter/SetColor",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LighterServer).SetColor(ctx, req.(*ColorMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _Lighter_SwitchState_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(StateMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(LighterServer).SwitchState(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/LighterGRPC.Lighter/SwitchState",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(LighterServer).SwitchState(ctx, req.(*StateMessage))
	}
	return interceptor(ctx, in, info, handler)
}

var _Lighter_serviceDesc = grpc.ServiceDesc{
	ServiceName: "LighterGRPC.Lighter",
	HandlerType: (*LighterServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ScheduleSwitchState",
			Handler:    _Lighter_ScheduleSwitchState_Handler,
		},
		{
			MethodName: "SetColor",
			Handler:    _Lighter_SetColor_Handler,
		},
		{
			MethodName: "SwitchState",
			Handler:    _Lighter_SwitchState_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "CheckConnection",
			Handler:       _Lighter_CheckConnection_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "LoadServerLog",
			Handler:       _Lighter_LoadServerLog_Handler,
			ServerStreams: true,
		},
	},
	Metadata: fileDescriptor1,
}

func init() { proto.RegisterFile("lighter.proto", fileDescriptor1) }

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