myroute.pb.go

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

/*
Package myrouteapp is a generated protocol buffer package.

It is generated from these files:
	myroute.proto

It has these top-level messages:
	Point
	Rectangle
	Feature
	RouteNote
	RouteSummary
*/
package myrouteapp

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"
)

// 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 Point struct {
	Lat int32 `protobuf:"varint,1,opt,name=lat" json:"lat,omitempty"`
	Lng int32 `protobuf:"varint,2,opt,name=lng" json:"lng,omitempty"`
}

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

func (m *Point) GetLat() int32 {
	if m != nil {
		return m.Lat
	}
	return 0
}

func (m *Point) GetLng() int32 {
	if m != nil {
		return m.Lng
	}
	return 0
}

// A latitude-longitude rectangle, represented as two diagonally opposite
// points "lo" and "hi".
type Rectangle struct {
	// One corner of the rectangle.
	Lo *Point `protobuf:"bytes,1,opt,name=lo" json:"lo,omitempty"`
	// The other corner of the rectangle.
	Hi *Point `protobuf:"bytes,2,opt,name=hi" json:"hi,omitempty"`
}

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

func (m *Rectangle) GetLo() *Point {
	if m != nil {
		return m.Lo
	}
	return nil
}

func (m *Rectangle) GetHi() *Point {
	if m != nil {
		return m.Hi
	}
	return nil
}

// A feature names something at a given point.
//
// If a feature could not be named, the name is empty.
type Feature struct {
	// The name of the feature.
	Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	// The point where the feature is detected.
	Location *Point `protobuf:"bytes,2,opt,name=location" json:"location,omitempty"`
}

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

func (m *Feature) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Feature) GetLocation() *Point {
	if m != nil {
		return m.Location
	}
	return nil
}

// A RouteNote is a message sent while at a given point.
type RouteNote struct {
	// The location from which the message is sent.
	Location *Point `protobuf:"bytes,1,opt,name=location" json:"location,omitempty"`
	// The message to be sent.
	Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
}

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

func (m *RouteNote) GetLocation() *Point {
	if m != nil {
		return m.Location
	}
	return nil
}

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

// A RouteSummary is received in response to a RecordRoute rpc.
//
// It contains the number of individual points received, the number of
// detected features, and the total distance covered as the cumulative sum of
// the distance between each point.
type RouteSummary struct {
	// The number of points received.
	PointCount int32 `protobuf:"varint,1,opt,name=point_count,json=pointCount" json:"point_count,omitempty"`
	// The number of known features passed while traversing the route.
	FeatureCount int32 `protobuf:"varint,2,opt,name=feature_count,json=featureCount" json:"feature_count,omitempty"`
	// The distance covered in metres.
	Distance int32 `protobuf:"varint,3,opt,name=distance" json:"distance,omitempty"`
	// The duration of the traversal in seconds.
	ElapsedTime int32 `protobuf:"varint,4,opt,name=elapsed_time,json=elapsedTime" json:"elapsed_time,omitempty"`
}

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

func (m *RouteSummary) GetPointCount() int32 {
	if m != nil {
		return m.PointCount
	}
	return 0
}

func (m *RouteSummary) GetFeatureCount() int32 {
	if m != nil {
		return m.FeatureCount
	}
	return 0
}

func (m *RouteSummary) GetDistance() int32 {
	if m != nil {
		return m.Distance
	}
	return 0
}

func (m *RouteSummary) GetElapsedTime() int32 {
	if m != nil {
		return m.ElapsedTime
	}
	return 0
}

func init() {
	proto.RegisterType((*Point)(nil), "myrouteapp.Point")
	proto.RegisterType((*Rectangle)(nil), "myrouteapp.Rectangle")
	proto.RegisterType((*Feature)(nil), "myrouteapp.Feature")
	proto.RegisterType((*RouteNote)(nil), "myrouteapp.RouteNote")
	proto.RegisterType((*RouteSummary)(nil), "myrouteapp.RouteSummary")
}

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

type MyRouteGuideClient interface {
	GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error)
	// Stream it back as it may be a lot of items ..
	ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (MyRouteGuide_ListFeaturesClient, error)
	// Send over the many points
	RecordRoute(ctx context.Context, opts ...grpc.CallOption) (MyRouteGuide_RecordRouteClient, error)
	// RouteNotes send from one to another ..
	RouteChat(ctx context.Context, opts ...grpc.CallOption) (MyRouteGuide_RouteChatClient, error)
}

type myRouteGuideClient struct {
	cc *grpc.ClientConn
}

func NewMyRouteGuideClient(cc *grpc.ClientConn) MyRouteGuideClient {
	return &myRouteGuideClient{cc}
}

func (c *myRouteGuideClient) GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error) {
	out := new(Feature)
	err := grpc.Invoke(ctx, "/myrouteapp.MyRouteGuide/GetFeature", in, out, c.cc, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *myRouteGuideClient) ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (MyRouteGuide_ListFeaturesClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_MyRouteGuide_serviceDesc.Streams[0], c.cc, "/myrouteapp.MyRouteGuide/ListFeatures", opts...)
	if err != nil {
		return nil, err
	}
	x := &myRouteGuideListFeaturesClient{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 MyRouteGuide_ListFeaturesClient interface {
	Recv() (*Feature, error)
	grpc.ClientStream
}

type myRouteGuideListFeaturesClient struct {
	grpc.ClientStream
}

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

func (c *myRouteGuideClient) RecordRoute(ctx context.Context, opts ...grpc.CallOption) (MyRouteGuide_RecordRouteClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_MyRouteGuide_serviceDesc.Streams[1], c.cc, "/myrouteapp.MyRouteGuide/RecordRoute", opts...)
	if err != nil {
		return nil, err
	}
	x := &myRouteGuideRecordRouteClient{stream}
	return x, nil
}

type MyRouteGuide_RecordRouteClient interface {
	Send(*Point) error
	CloseAndRecv() (*RouteSummary, error)
	grpc.ClientStream
}

type myRouteGuideRecordRouteClient struct {
	grpc.ClientStream
}

func (x *myRouteGuideRecordRouteClient) Send(m *Point) error {
	return x.ClientStream.SendMsg(m)
}

func (x *myRouteGuideRecordRouteClient) CloseAndRecv() (*RouteSummary, error) {
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	m := new(RouteSummary)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

func (c *myRouteGuideClient) RouteChat(ctx context.Context, opts ...grpc.CallOption) (MyRouteGuide_RouteChatClient, error) {
	stream, err := grpc.NewClientStream(ctx, &_MyRouteGuide_serviceDesc.Streams[2], c.cc, "/myrouteapp.MyRouteGuide/RouteChat", opts...)
	if err != nil {
		return nil, err
	}
	x := &myRouteGuideRouteChatClient{stream}
	return x, nil
}

type MyRouteGuide_RouteChatClient interface {
	Send(*RouteNote) error
	Recv() (*RouteNote, error)
	grpc.ClientStream
}

type myRouteGuideRouteChatClient struct {
	grpc.ClientStream
}

func (x *myRouteGuideRouteChatClient) Send(m *RouteNote) error {
	return x.ClientStream.SendMsg(m)
}

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

// Server API for MyRouteGuide service

type MyRouteGuideServer interface {
	GetFeature(context.Context, *Point) (*Feature, error)
	// Stream it back as it may be a lot of items ..
	ListFeatures(*Rectangle, MyRouteGuide_ListFeaturesServer) error
	// Send over the many points
	RecordRoute(MyRouteGuide_RecordRouteServer) error
	// RouteNotes send from one to another ..
	RouteChat(MyRouteGuide_RouteChatServer) error
}

func RegisterMyRouteGuideServer(s *grpc.Server, srv MyRouteGuideServer) {
	s.RegisterService(&_MyRouteGuide_serviceDesc, srv)
}

func _MyRouteGuide_GetFeature_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Point)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MyRouteGuideServer).GetFeature(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/myrouteapp.MyRouteGuide/GetFeature",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MyRouteGuideServer).GetFeature(ctx, req.(*Point))
	}
	return interceptor(ctx, in, info, handler)
}

func _MyRouteGuide_ListFeatures_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(Rectangle)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(MyRouteGuideServer).ListFeatures(m, &myRouteGuideListFeaturesServer{stream})
}

type MyRouteGuide_ListFeaturesServer interface {
	Send(*Feature) error
	grpc.ServerStream
}

type myRouteGuideListFeaturesServer struct {
	grpc.ServerStream
}

func (x *myRouteGuideListFeaturesServer) Send(m *Feature) error {
	return x.ServerStream.SendMsg(m)
}

func _MyRouteGuide_RecordRoute_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MyRouteGuideServer).RecordRoute(&myRouteGuideRecordRouteServer{stream})
}

type MyRouteGuide_RecordRouteServer interface {
	SendAndClose(*RouteSummary) error
	Recv() (*Point, error)
	grpc.ServerStream
}

type myRouteGuideRecordRouteServer struct {
	grpc.ServerStream
}

func (x *myRouteGuideRecordRouteServer) SendAndClose(m *RouteSummary) error {
	return x.ServerStream.SendMsg(m)
}

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

func _MyRouteGuide_RouteChat_Handler(srv interface{}, stream grpc.ServerStream) error {
	return srv.(MyRouteGuideServer).RouteChat(&myRouteGuideRouteChatServer{stream})
}

type MyRouteGuide_RouteChatServer interface {
	Send(*RouteNote) error
	Recv() (*RouteNote, error)
	grpc.ServerStream
}

type myRouteGuideRouteChatServer struct {
	grpc.ServerStream
}

func (x *myRouteGuideRouteChatServer) Send(m *RouteNote) error {
	return x.ServerStream.SendMsg(m)
}

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

var _MyRouteGuide_serviceDesc = grpc.ServiceDesc{
	ServiceName: "myrouteapp.MyRouteGuide",
	HandlerType: (*MyRouteGuideServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetFeature",
			Handler:    _MyRouteGuide_GetFeature_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "ListFeatures",
			Handler:       _MyRouteGuide_ListFeatures_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "RecordRoute",
			Handler:       _MyRouteGuide_RecordRoute_Handler,
			ClientStreams: true,
		},
		{
			StreamName:    "RouteChat",
			Handler:       _MyRouteGuide_RouteChat_Handler,
			ServerStreams: true,
			ClientStreams: true,
		},
	},
	Metadata: "myroute.proto",
}

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

var fileDescriptor0 = []byte{
	// 371 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x52, 0x41, 0x4f, 0xf2, 0x40,
	0x10, 0xa5, 0x05, 0x3e, 0xe8, 0xb4, 0x24, 0xdf, 0x37, 0x5f, 0x4c, 0x1a, 0x2e, 0x4a, 0xbd, 0x90,
	0x18, 0x09, 0xc1, 0xc4, 0x23, 0x1e, 0x48, 0xe4, 0x82, 0x46, 0x2b, 0x77, 0xb2, 0xb6, 0x63, 0xd9,
	0xa4, 0xdd, 0x6d, 0xda, 0xed, 0x81, 0x5f, 0xe0, 0x0f, 0xf0, 0x0f, 0x9b, 0x2e, 0x2d, 0x82, 0x42,
	0xbc, 0xed, 0xbc, 0x79, 0xef, 0xcd, 0xee, 0x9b, 0x85, 0x5e, 0xb2, 0xc9, 0x64, 0xa1, 0x68, 0x94,
	0x66, 0x52, 0x49, 0x84, 0xaa, 0x64, 0x69, 0xea, 0x5d, 0x41, 0xfb, 0x49, 0x72, 0xa1, 0xf0, 0x2f,
	0x34, 0x63, 0xa6, 0x5c, 0xe3, 0xc2, 0x18, 0xb6, 0xfd, 0xf2, 0xa8, 0x11, 0x11, 0xb9, 0x66, 0x85,
	0x88, 0xc8, 0x7b, 0x06, 0xcb, 0xa7, 0x40, 0x31, 0x11, 0xc5, 0x84, 0x03, 0x30, 0x63, 0xa9, 0xf9,
	0xf6, 0xe4, 0xdf, 0xe8, 0xcb, 0x72, 0xa4, 0xfd, 0x7c, 0x33, 0x96, 0x25, 0x65, 0xcd, 0xb5, 0xc1,
	0x71, 0xca, 0x9a, 0x7b, 0x0b, 0xe8, 0xdc, 0x13, 0x53, 0x45, 0x46, 0x88, 0xd0, 0x12, 0x2c, 0x21,
	0x6d, 0x69, 0xf9, 0xfa, 0x8c, 0xd7, 0xd0, 0x8d, 0x65, 0xc0, 0x14, 0x97, 0xe2, 0xb4, 0xcf, 0x8e,
	0xe2, 0x2d, 0xc1, 0xf2, 0xcb, 0xde, 0xa3, 0x54, 0x87, 0x5a, 0xe3, 0x57, 0x2d, 0xba, 0xd0, 0x49,
	0x28, 0xcf, 0x59, 0x44, 0x7a, 0x92, 0xe5, 0xd7, 0xa5, 0xf7, 0x61, 0x80, 0xa3, 0x6d, 0x5f, 0x8a,
	0x24, 0x61, 0xd9, 0x06, 0xcf, 0xc1, 0x4e, 0x4b, 0xf5, 0x2a, 0x90, 0x85, 0xa8, 0x33, 0x03, 0x0d,
	0xcd, 0x4a, 0x04, 0x2f, 0xa1, 0xf7, 0xb6, 0x7d, 0x55, 0x45, 0xd9, 0x86, 0xe8, 0x54, 0xe0, 0x96,
	0xd4, 0x87, 0x6e, 0xc8, 0x73, 0xc5, 0x44, 0x40, 0x6e, 0x53, 0xf7, 0x77, 0x35, 0x0e, 0xc0, 0xa1,
	0x98, 0xa5, 0x39, 0x85, 0x2b, 0xc5, 0x13, 0x72, 0x5b, 0xba, 0x6f, 0x57, 0xd8, 0x92, 0x27, 0x34,
	0x79, 0x37, 0xc1, 0x79, 0xd8, 0xe8, 0x7b, 0xcd, 0x0b, 0x1e, 0x12, 0xde, 0x02, 0xcc, 0x49, 0xd5,
	0x69, 0xfe, 0x7c, 0x6b, 0xff, 0xff, 0x3e, 0x54, 0xf1, 0xbc, 0x06, 0x4e, 0xc1, 0x59, 0xf0, 0xbc,
	0x16, 0xe6, 0x78, 0xb6, 0x4f, 0xdb, 0xed, 0xfb, 0x84, 0x7a, 0x6c, 0xe0, 0x14, 0x6c, 0x9f, 0x02,
	0x99, 0x85, 0xfa, 0x2e, 0xc7, 0x06, 0xbb, 0x07, 0x8e, 0x7b, 0x49, 0x7a, 0x8d, 0xa1, 0x81, 0x77,
	0xd5, 0xd2, 0x66, 0x6b, 0xa6, 0xbe, 0x0d, 0xaf, 0x77, 0xd9, 0x3f, 0x0e, 0x97, 0xf2, 0xb1, 0xf1,
	0xfa, 0x47, 0x7f, 0xeb, 0x9b, 0xcf, 0x00, 0x00, 0x00, 0xff, 0xff, 0x96, 0x97, 0xaa, 0xb3, 0xe7,
	0x02, 0x00, 0x00,
}