// The greeting service definition.
service Greeter {
  // Sends a greeting
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}
message HelloRequest {
  string name = 1;
}
message HelloReply {
  string message = 1;
} 

type HelloRequest struct {
  Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}

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

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

func init() {
  proto.RegisterType((*HelloRequest)(nil), "HelloRequest")
  proto.RegisterType((*HelloReply)(nil), "HelloReply")
}

type GreeterClient interface {
  // Sends a greeting                                                                               
  SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*HelloReply, error)
}

type greeterClient struct {
  cc *grpc.ClientConn
}

func NewGreeterClient(cc *grpc.ClientConn) GreeterClient {
  return &greeterClient{cc}
}

func (c *greeterClient) SayHello(ctx context.Context, in *HelloRequest, opts ...grpc.CallOption) (*\
HelloReply, error) {
  out := new(HelloReply)
  err := grpc.Invoke(ctx, "/Greeter/SayHello", in, out, c.cc, opts...)
  if err != nil {
    return nil, err
  }
  return out, nil
}

type GreeterServer interface {
  // Sends a greeting                                                                               
  SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}

func RegisterGreeterServer(s *grpc.Server, srv GreeterServer) {
  s.RegisterService(&_Greeter_serviceDesc, srv)
}

func _Greeter_SayHello_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, i\
nterceptor grpc.UnaryServerInterceptor) (interface{}, error) {
  in := new(HelloRequest)
  if err := dec(in); err != nil {
    return nil, err
  }
  if interceptor == nil {
    return srv.(GreeterServer).SayHello(ctx, in)
  }
  info := &grpc.UnaryServerInfo{
    Server:     srv,
    FullMethod: "/Greeter/SayHello",
  }
  handler := func(ctx context.Context, req interface{}) (interface{}, error) {
    return srv.(GreeterServer).SayHello(ctx, req.(*HelloRequest))
  }
  return interceptor(ctx, in, info, handler)
}

var _Greeter_serviceDesc = grpc.ServiceDesc{
  ServiceName: "Greeter",
  HandlerType: (*GreeterServer)(nil),
  Methods: []grpc.MethodDesc{
    {
      MethodName: "SayHello",
      Handler:    _Greeter_SayHello_Handler,
    },
  },
  Streams:  []grpc.StreamDesc{},
  Metadata: "greeter.proto",
}

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

var fileDescriptor0 = []byte{
  // 128 bytes of a gzipped FileDescriptorProto                                                     
  0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xe2, 0xe2, 0x4d, 0x2f, 0x4a, 0x4d,
  0x2d, 0x49, 0x2d, 0xd2, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x57, 0x52, 0xe2, 0xe2, 0xf1, 0x48, 0xcd,
  0xc9, 0xc9, 0x0f, 0x4a, 0x2d, 0x2c, 0x4d, 0x2d, 0x2e, 0x11, 0x12, 0xe2, 0x62, 0xc9, 0x4b, 0xcc,
  0x4d, 0x95, 0x60, 0x54, 0x60, 0xd4, 0xe0, 0x0c, 0x02, 0xb3, 0x95, 0xd4, 0xb8, 0xb8, 0xa0, 0x6a,
  0x0a, 0x72, 0x2a, 0x85, 0x24, 0xb8, 0xd8, 0x73, 0x53, 0x8b, 0x8b, 0x13, 0xd3, 0x61, 0x8a, 0x60,
  0x5c, 0x23, 0x63, 0x2e, 0x76, 0x77, 0x88, 0xe1, 0x42, 0x1a, 0x5c, 0x1c, 0xc1, 0x89, 0x95, 0x60,
  0x5d, 0x42, 0xbc, 0x7a, 0xc8, 0x36, 0x48, 0x71, 0xeb, 0x21, 0x0c, 0x53, 0x62, 0x48, 0x62, 0x03,
  0xbb, 0xc3, 0x18, 0x10, 0x00, 0x00, 0xff, 0xff, 0x25, 0x8f, 0x65, 0x75, 0x98, 0x00, 0x00, 0x00,
}