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

/*
Package gwrpc is a generated protocol buffer package.

It is generated from these files:
	grpc/grpc.proto

It has these top-level messages:
	ServiceInput
	ServiceOutput
	EchoRequest
	EchoResponse
	Heartbeat
	Empty
*/
package gwrpc

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
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 _ = 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 Heartbeat_Status int32

const (
	Heartbeat_UNKNOWN Heartbeat_Status = 0
	Heartbeat_OK      Heartbeat_Status = 1
)

var Heartbeat_Status_name = map[int32]string{
	0: "UNKNOWN",
	1: "OK",
}
var Heartbeat_Status_value = map[string]int32{
	"UNKNOWN": 0,
	"OK":      1,
}

func (x Heartbeat_Status) String() string {
	return proto.EnumName(Heartbeat_Status_name, int32(x))
}
func (Heartbeat_Status) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4, 0} }

type ServiceInput struct {
	ServiceName string            `protobuf:"bytes,1,opt,name=serviceName" json:"serviceName,omitempty"`
	MethodName  string            `protobuf:"bytes,2,opt,name=methodName" json:"methodName,omitempty"`
	Param       map[string]string `protobuf:"bytes,3,rep,name=param" json:"param,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

func (m *ServiceInput) GetServiceName() string {
	if m != nil {
		return m.ServiceName
	}
	return ""
}

func (m *ServiceInput) GetMethodName() string {
	if m != nil {
		return m.MethodName
	}
	return ""
}

func (m *ServiceInput) GetParam() map[string]string {
	if m != nil {
		return m.Param
	}
	return nil
}

type ServiceOutput struct {
	ResultStr string `protobuf:"bytes,1,opt,name=resultStr" json:"resultStr,omitempty"`
}

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

func (m *ServiceOutput) GetResultStr() string {
	if m != nil {
		return m.ResultStr
	}
	return ""
}

type EchoRequest struct {
	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
}

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

func (m *EchoRequest) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type EchoResponse struct {
	Message string `protobuf:"bytes,1,opt,name=message" json:"message,omitempty"`
}

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

func (m *EchoResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type Heartbeat struct {
	Status Heartbeat_Status `protobuf:"varint,1,opt,name=status,enum=gwrpc.Heartbeat_Status" json:"status,omitempty"`
}

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

func (m *Heartbeat) GetStatus() Heartbeat_Status {
	if m != nil {
		return m.Status
	}
	return Heartbeat_UNKNOWN
}

type Empty struct {
}

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

func init() {
	proto.RegisterType((*ServiceInput)(nil), "gwrpc.ServiceInput")
	proto.RegisterType((*ServiceOutput)(nil), "gwrpc.ServiceOutput")
	proto.RegisterType((*EchoRequest)(nil), "gwrpc.EchoRequest")
	proto.RegisterType((*EchoResponse)(nil), "gwrpc.EchoResponse")
	proto.RegisterType((*Heartbeat)(nil), "gwrpc.Heartbeat")
	proto.RegisterType((*Empty)(nil), "gwrpc.Empty")
	proto.RegisterEnum("gwrpc.Heartbeat_Status", Heartbeat_Status_name, Heartbeat_Status_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 OverflowGateway service

type OverflowGatewayClient interface {
	ExecServices(ctx context.Context, in *ServiceInput, opts ...grpc.CallOption) (*ServiceOutput, error)
}

type overflowGatewayClient struct {
	cc *grpc.ClientConn
}

func NewOverflowGatewayClient(cc *grpc.ClientConn) OverflowGatewayClient {
	return &overflowGatewayClient{cc}
}

func (c *overflowGatewayClient) ExecServices(ctx context.Context, in *ServiceInput, opts ...grpc.CallOption) (*ServiceOutput, error) {
	out := new(ServiceOutput)
	err := grpc.Invoke(ctx, "/gwrpc.OverflowGateway/ExecServices", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// Server API for OverflowGateway service

type OverflowGatewayServer interface {
	ExecServices(context.Context, *ServiceInput) (*ServiceOutput, error)
}

func RegisterOverflowGatewayServer(s *grpc.Server, srv OverflowGatewayServer) {
	s.RegisterService(&_OverflowGateway_serviceDesc, srv)
}

func _OverflowGateway_ExecServices_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ServiceInput)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OverflowGatewayServer).ExecServices(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/gwrpc.OverflowGateway/ExecServices",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OverflowGatewayServer).ExecServices(ctx, req.(*ServiceInput))
	}
	return interceptor(ctx, in, info, handler)
}

var _OverflowGateway_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gwrpc.OverflowGateway",
	HandlerType: (*OverflowGatewayServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ExecServices",
			Handler:    _OverflowGateway_ExecServices_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "grpc/grpc.proto",
}

// Client API for EchoService service

type EchoServiceClient interface {
	Echo(ctx context.Context, opts ...grpc.CallOption) (EchoService_EchoClient, error)
	Stream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (EchoService_StreamClient, error)
	Heartbeats(ctx context.Context, opts ...grpc.CallOption) (EchoService_HeartbeatsClient, error)
}

type echoServiceClient struct {
	cc *grpc.ClientConn
}

func NewEchoServiceClient(cc *grpc.ClientConn) EchoServiceClient {
	return &echoServiceClient{cc}
}

func (c *echoServiceClient) Echo(ctx context.Context, opts ...grpc.CallOption) (EchoService_EchoClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_EchoService_serviceDesc.Streams[0], c.cc, "/gwrpc.EchoService/Echo", opts...)
	if err != nil {
		return nil, err
	}
	x := &echoServiceEchoClient{stream}
	return x, nil
}

type EchoService_EchoClient interface {
	Send(*EchoRequest) error
	Recv() (*EchoResponse, error)
	grpc.ClientStream
}

type echoServiceEchoClient struct {
	grpc.ClientStream
}

func (x *echoServiceEchoClient) Send(m *EchoRequest) error {
	return x.ClientStream.SendMsg(m)
}

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

func (c *echoServiceClient) Stream(ctx context.Context, in *Empty, opts ...grpc.CallOption) (EchoService_StreamClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_EchoService_serviceDesc.Streams[1], c.cc, "/gwrpc.EchoService/Stream", opts...)
	if err != nil {
		return nil, err
	}
	x := &echoServiceStreamClient{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 EchoService_StreamClient interface {
	Recv() (*EchoResponse, error)
	grpc.ClientStream
}

type echoServiceStreamClient struct {
	grpc.ClientStream
}

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

func (c *echoServiceClient) Heartbeats(ctx context.Context, opts ...grpc.CallOption) (EchoService_HeartbeatsClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_EchoService_serviceDesc.Streams[2], c.cc, "/gwrpc.EchoService/Heartbeats", opts...)
	if err != nil {
		return nil, err
	}
	x := &echoServiceHeartbeatsClient{stream}
	return x, nil
}

type EchoService_HeartbeatsClient interface {
	Send(*Empty) error
	Recv() (*Heartbeat, error)
	grpc.ClientStream
}

type echoServiceHeartbeatsClient struct {
	grpc.ClientStream
}

func (x *echoServiceHeartbeatsClient) Send(m *Empty) error {
	return x.ClientStream.SendMsg(m)
}

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

// Server API for EchoService service

type EchoServiceServer interface {
	Echo(EchoService_EchoServer) error
	Stream(*Empty, EchoService_StreamServer) error
	Heartbeats(EchoService_HeartbeatsServer) error
}

func RegisterEchoServiceServer(s *grpc.Server, srv EchoServiceServer) {
	s.RegisterService(&_EchoService_serviceDesc, srv)
}

func _EchoService_Echo_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(EchoServiceServer).Echo(&echoServiceEchoServer{stream})
}

type EchoService_EchoServer interface {
	Send(*EchoResponse) error
	Recv() (*EchoRequest, error)
	grpc.ServerStream
}

type echoServiceEchoServer struct {
	grpc.ServerStream
}

func (x *echoServiceEchoServer) Send(m *EchoResponse) error {
	return x.ServerStream.SendMsg(m)
}

func (x *echoServiceEchoServer) Recv() (*EchoRequest, error) {
	m := new(EchoRequest)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func _EchoService_Stream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Empty)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(EchoServiceServer).Stream(m, &echoServiceStreamServer{stream})
}

type EchoService_StreamServer interface {
	Send(*EchoResponse) error
	grpc.ServerStream
}

type echoServiceStreamServer struct {
	grpc.ServerStream
}

func (x *echoServiceStreamServer) Send(m *EchoResponse) error {
	return x.ServerStream.SendMsg(m)
}

func _EchoService_Heartbeats_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(EchoServiceServer).Heartbeats(&echoServiceHeartbeatsServer{stream})
}

type EchoService_HeartbeatsServer interface {
	Send(*Heartbeat) error
	Recv() (*Empty, error)
	grpc.ServerStream
}

type echoServiceHeartbeatsServer struct {
	grpc.ServerStream
}

func (x *echoServiceHeartbeatsServer) Send(m *Heartbeat) error {
	return x.ServerStream.SendMsg(m)
}

func (x *echoServiceHeartbeatsServer) Recv() (*Empty, error) {
	m := new(Empty)
	if err := x.ServerStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

var _EchoService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "gwrpc.EchoService",
	HandlerType: (*EchoServiceServer)(nil),
	Methods:     []grpc.MethodDesc{},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "Echo",
			Handler:       _EchoService_Echo_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
		{
			StreamName:    "Stream",
			Handler:       _EchoService_Stream_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "Heartbeats",
			Handler:       _EchoService_Heartbeats_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "grpc/grpc.proto",
}

func init() { proto.RegisterFile("grpc/grpc.proto", fileDescriptor0) }

var fileDescriptor0 = []byte{
	// 473 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x92, 0xc1, 0x6e, 0xd3, 0x40,
	0x10, 0x86, 0xd9, 0x84, 0x24, 0xca, 0x38, 0xa1, 0xd6, 0xa4, 0x88, 0xc8, 0x2a, 0x55, 0xb4, 0x17,
	0xa2, 0x4a, 0xd8, 0x25, 0x70, 0xa8, 0x22, 0xae, 0x16, 0xa0, 0x4a, 0x09, 0x4a, 0x84, 0x38, 0xf4,
	0xb4, 0x35, 0x8b, 0x13, 0x11, 0x7b, 0xcd, 0xee, 0x3a, 0x21, 0x57, 0x5e, 0x81, 0x17, 0xe2, 0x1d,
	0x38, 0x71, 0xe7, 0x41, 0x90, 0x77, 0x37, 0x69, 0x5a, 0x55, 0xbd, 0x58, 0x9e, 0xdf, 0xdf, 0xfc,
	0xb3, 0xf3, 0x7b, 0xe1, 0x28, 0x95, 0x45, 0x12, 0x55, 0x8f, 0xb0, 0x90, 0x42, 0x0b, 0x6c, 0xa4,
	0x1b, 0x59, 0x24, 0xc1, 0x49, 0x2a, 0x44, 0xba, 0xe2, 0x11, 0x2b, 0x96, 0x11, 0xcb, 0x73, 0xa1,
	0x99, 0x5e, 0x8a, 0x5c, 0x59, 0x88, 0xfe, 0x26, 0xd0, 0x99, 0x73, 0xb9, 0x5e, 0x26, 0xfc, 0x43,
	0x5e, 0x94, 0x1a, 0x07, 0xe0, 0x29, 0x5b, 0x4f, 0x58, 0xc6, 0xfb, 0x64, 0x40, 0x86, 0xed, 0xd9,
	0xa1, 0x84, 0xa7, 0x00, 0x19, 0xd7, 0x0b, 0xf1, 0xc5, 0x00, 0x35, 0x03, 0x1c, 0x28, 0xf8, 0x06,
	0x1a, 0x05, 0x93, 0x2c, 0xeb, 0xd7, 0x07, 0xf5, 0xa1, 0x37, 0x3a, 0x0d, 0xcd, 0x39, 0xc2, 0xc3,
	0x29, 0xe1, 0xc7, 0x0a, 0x88, 0x73, 0x2d, 0xb7, 0x33, 0x0b, 0x07, 0x17, 0x00, 0x37, 0x22, 0xfa,
	0x50, 0xff, 0xc6, 0xb7, 0x6e, 0x7a, 0xf5, 0x8a, 0xc7, 0xd0, 0x58, 0xb3, 0x55, 0xb9, 0x1b, 0x68,
	0x8b, 0x71, 0xed, 0x82, 0xd0, 0x97, 0xd0, 0x75, 0xde, 0xd3, 0x52, 0x57, 0x2b, 0x9c, 0x40, 0x5b,
	0x72, 0x55, 0xae, 0xf4, 0x5c, 0x4b, 0x67, 0x71, 0x23, 0xd0, 0x17, 0xe0, 0xc5, 0xc9, 0x42, 0xcc,
	0xf8, 0xf7, 0x92, 0x2b, 0x8d, 0x7d, 0x68, 0x65, 0x5c, 0x29, 0x96, 0xee, 0x76, 0xdd, 0x95, 0x74,
	0x08, 0x1d, 0x0b, 0xaa, 0x42, 0xe4, 0x8a, 0x3f, 0x40, 0x5e, 0x41, 0xfb, 0x3d, 0x67, 0x52, 0x5f,
	0x73, 0xa6, 0x31, 0x82, 0xa6, 0xd2, 0x4c, 0x97, 0xca, 0x50, 0x4f, 0x46, 0xcf, 0xdc, 0xfe, 0x7b,
	0x22, 0x9c, 0x9b, 0xcf, 0x33, 0x87, 0xd1, 0xe7, 0xd0, 0xb4, 0x0a, 0x7a, 0xd0, 0xfa, 0x34, 0xb9,
	0x9c, 0x4c, 0x3f, 0x4f, 0xfc, 0x47, 0xd8, 0x84, 0xda, 0xf4, 0xd2, 0x27, 0xb4, 0x05, 0x8d, 0x38,
	0x2b, 0xf4, 0x76, 0x94, 0xc3, 0xd1, 0x74, 0xcd, 0xe5, 0xd7, 0x95, 0xd8, 0xbc, 0x63, 0x9a, 0x6f,
	0xd8, 0x16, 0xaf, 0xa0, 0x13, 0xff, 0xe0, 0x89, 0x5b, 0x5f, 0x61, 0xef, 0x9e, 0xac, 0x83, 0xe3,
	0xdb, 0xa2, 0x0d, 0x89, 0x0e, 0x7e, 0xfe, 0xf9, 0xf7, 0xab, 0x16, 0xd0, 0xa7, 0xd1, 0xfa, 0x55,
	0x24, 0x9c, 0x6f, 0xe4, 0xfe, 0xb3, 0x1a, 0x93, 0xb3, 0xd1, 0x5f, 0x62, 0x93, 0x72, 0x7d, 0x18,
	0xc3, 0xe3, 0xaa, 0x44, 0x74, 0x7e, 0x07, 0x29, 0x06, 0xbd, 0x5b, 0x9a, 0x0d, 0x8c, 0xfa, 0x66,
	0x04, 0xd0, 0x46, 0xc4, 0x93, 0x85, 0x18, 0x93, 0xb3, 0x21, 0x39, 0x27, 0xf8, 0xb6, 0x5a, 0x57,
	0x72, 0x96, 0x61, 0x67, 0xd7, 0x54, 0xad, 0x77, 0xbf, 0x45, 0xd7, 0x58, 0xb4, 0xd0, 0x5a, 0x9c,
	0x13, 0x8c, 0x01, 0xf6, 0x41, 0xaa, 0x3b, 0x0e, 0xfe, 0xdd, 0xa4, 0x69, 0xcf, 0xb4, 0x77, 0xa9,
	0x17, 0x2d, 0xf6, 0x4d, 0xd5, 0x21, 0xae, 0x9b, 0xe6, 0xf6, 0xbf, 0xfe, 0x1f, 0x00, 0x00, 0xff,
	0xff, 0xec, 0x37, 0x72, 0xa5, 0x35, 0x03, 0x00, 0x00,
}