add operator_type

liuxiaolong

2020-07-13 4922436eb78c6e6735c7fb6ce4920c67a449cbf0

 facedetect.pb.go

@@ -4,10 +4,15 @@
package protomsg

import (
   context "context"
   fmt "fmt"
   proto "github.com/gogo/protobuf/proto"
   grpc "google.golang.org/grpc"
   codes "google.golang.org/grpc/codes"
   status "google.golang.org/grpc/status"
   io "io"
   math "math"
   math_bits "math/bits"
)

// Reference imports to suppress errors if they are not otherwise used.
@@ -85,6 +90,86 @@
   0x04, 0x00, 0x00, 0xff, 0xff, 0x92, 0xe0, 0xfb, 0x5b, 0xcd, 0x00, 0x00, 0x00,
}

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

// FaceDetectClient is the client API for FaceDetect service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type FaceDetectClient interface {
   FaceDetect(ctx context.Context, in *FaceDetectRequest, opts ...grpc.CallOption) (*ParamFacePos, error)
}

type faceDetectClient struct {
   cc *grpc.ClientConn
}

func NewFaceDetectClient(cc *grpc.ClientConn) FaceDetectClient {
   return &faceDetectClient{cc}
}

func (c *faceDetectClient) FaceDetect(ctx context.Context, in *FaceDetectRequest, opts ...grpc.CallOption) (*ParamFacePos, error) {
   out := new(ParamFacePos)
   err := c.cc.Invoke(ctx, "/protomsg.FaceDetect/FaceDetect", in, out, opts...)
   if err != nil {
      return nil, err
   }
   return out, nil
}

// FaceDetectServer is the server API for FaceDetect service.
type FaceDetectServer interface {
   FaceDetect(context.Context, *FaceDetectRequest) (*ParamFacePos, error)
}

// UnimplementedFaceDetectServer can be embedded to have forward compatible implementations.
type UnimplementedFaceDetectServer struct {
}

func (*UnimplementedFaceDetectServer) FaceDetect(ctx context.Context, req *FaceDetectRequest) (*ParamFacePos, error) {
   return nil, status.Errorf(codes.Unimplemented, "method FaceDetect not implemented")
}

func RegisterFaceDetectServer(s *grpc.Server, srv FaceDetectServer) {
   s.RegisterService(&_FaceDetect_serviceDesc, srv)
}

func _FaceDetect_FaceDetect_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
   in := new(FaceDetectRequest)
   if err := dec(in); err != nil {
      return nil, err
   }
   if interceptor == nil {
      return srv.(FaceDetectServer).FaceDetect(ctx, in)
   }
   info := &grpc.UnaryServerInfo{
      Server:     srv,
      FullMethod: "/protomsg.FaceDetect/FaceDetect",
   }
   handler := func(ctx context.Context, req interface{}) (interface{}, error) {
      return srv.(FaceDetectServer).FaceDetect(ctx, req.(*FaceDetectRequest))
   }
   return interceptor(ctx, in, info, handler)
}

var _FaceDetect_serviceDesc = grpc.ServiceDesc{
   ServiceName: "protomsg.FaceDetect",
   HandlerType: (*FaceDetectServer)(nil),
   Methods: []grpc.MethodDesc{
      {
         MethodName: "FaceDetect",
         Handler:    _FaceDetect_FaceDetect_Handler,
      },
   },
   Streams:  []grpc.StreamDesc{},
   Metadata: "facedetect.proto",
}

func (m *FaceDetectRequest) Marshal() (dAtA []byte, err error) {
   size := m.Size()
   dAtA = make([]byte, size)
@@ -132,14 +217,7 @@
}

func sovFacedetect(x uint64) (n int) {
   for {
      n++
      x >>= 7
      if x == 0 {
         break
      }
   }
   return n
   return (math_bits.Len64(x|1) + 6) / 7
}
func sozFacedetect(x uint64) (n int) {
   return sovFacedetect(uint64((x << 1) ^ uint64((int64(x) >> 63))))