add driver/driver_group_grpc_client for group info.

src/driver/driver_group_grpc_client/.gitignore

@@ -0,0 +1,73 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+

src/driver/driver_group_grpc_client/driver_group_grpc_client.pro

@@ -0,0 +1,58 @@
+QT -= gui
+
+CONFIG += c++11 console
+CONFIG -= app_bundle
+
+# The following define makes your compiler emit warnings if you use
+# any Qt feature that has been marked deprecated (the exact warnings
+# depend on your compiler). Please consult the documentation of the
+# deprecated API in order to know how to port your code away from it.
+DEFINES += QT_DEPRECATED_WARNINGS
+
+
+system(protoc -I=./../../include/proto3 --cpp_out=./../../include/msgtype   ./../../include/proto3/grpcgroup.proto)
+# You can also make your code fail to compile if it uses deprecated APIs.
+# In order to do so, uncomment the following line.
+# You can also select to disable deprecated APIs only up to a certain version of Qt.
+#DEFINES += QT_DISABLE_DEPRECATED_BEFORE=0x060000    # disables all the APIs deprecated before Qt 6.0.0
+
+SOURCES += \
+        ../../include/msgtype/brainstate.pb.cc \
+        ../../include/msgtype/decition.pb.cc \
+        ../../include/msgtype/gps.pb.cc \
+        ../../include/msgtype/gpsimu.pb.cc \
+        ../../include/msgtype/groupmsg.pb.cc \
+        ../../include/msgtype/grpcgroup.pb.cc \
+        ../../include/msgtype/imu.pb.cc \
+        groupclient.cpp \
+        grpcgroup.grpc.pb.cc \
+        main.cpp
+
+# Default rules for deployment.
+qnx: target.path = /tmp/$${TARGET}/bin
+else: unix:!android: target.path = /opt/$${TARGET}/bin
+!isEmpty(target.path): INSTALLS += target
+
+HEADERS += \
+    ../../include/msgtype/brainstate.pb.h \
+    ../../include/msgtype/decition.pb.h \
+    ../../include/msgtype/gps.pb.h \
+    ../../include/msgtype/gpsimu.pb.h \
+    ../../include/msgtype/groupmsg.pb.h \
+    ../../include/msgtype/grpcgroup.pb.h \
+    ../../include/msgtype/imu.pb.h \
+    groupclient.h \
+    grpcgroup.grpc.pb.h
+
+!include(../../../include/common.pri ) {
+    error( "Couldn't find the common.pri file!" )
+}
+
+!include(../../../include/ivprotobuf.pri ) {
+    error( "Couldn't find the ivprotobuf.pri file!" )
+}
+
+
+!include(../../../include/ivgrpc.pri ) {
+    error( "Couldn't find the ivgrpc.pri file!" )
+}

src/driver/driver_group_grpc_client/groupclient.cpp

@@ -0,0 +1,170 @@
+#include "groupclient.h"
+
+groupclient::groupclient()
+{
+    mpabrain = new iv::modulecommext::modulecommmsg<iv::brain::brainstate>();
+    ModuleExtFun funbrain = std::bind(&groupclient::ListenBrain,this,std::placeholders::_1);
+    mpabrain->RegisterRecvPlus(mstrbrainmsgname.data(),funbrain);
+
+    mpadecition = new iv::modulecommext::modulecommmsg<iv::brain::decition>();
+    ModuleExtFun fundecition = std::bind(&groupclient::ListenDecition,this,std::placeholders::_1);
+    mpadecition->RegisterRecvPlus(mstrdecitionmsgname.data(),fundecition);
+
+    mpagpsimu = new iv::modulecommext::modulecommmsg<iv::gps::gpsimu>();
+    ModuleExtFun fungpsimu = std::bind(&groupclient::ListenGPSIMU,this,std::placeholders::_1);
+    mpagpsimu->RegisterRecvPlus(mstrgpsimumsgname.data(),fungpsimu);
+
+    mpagroup = new iv::modulecommext::modulecommmsg<iv::group::groupinfo>();
+    mpagroup->RegisterSend(mstrgroupmsgname.data(),100000,1);
+
+}
+
+void groupclient::ListenBrain(google::protobuf::Message &xmsg)
+{
+    mMutexBrain.lock();
+    mnbrainupdate = QDateTime::currentMSecsSinceEpoch();
+    mbrainstate.CopyFrom(xmsg);
+    mMutexBrain.unlock();
+}
+
+void groupclient::ListenDecition(google::protobuf::Message &xmsg)
+{
+    mMutexDecition.lock();
+    mndecitionupdate = QDateTime::currentMSecsSinceEpoch();
+    mdecition.CopyFrom(xmsg);
+    mMutexDecition.unlock();
+}
+
+void groupclient::ListenGPSIMU(google::protobuf::Message &xmsg)
+{
+    mMutexGPSIMU.lock();
+    mngpsimuupdate = QDateTime::currentMSecsSinceEpoch();
+    mgpsimu.CopyFrom(xmsg);
+    mMutexGPSIMU.unlock();
+}
+
+void groupclient::run()
+{
+    int ninterval = mnInterval;
+    if(ninterval<=0)ninterval = 1000;
+
+    QTime xTime;
+    xTime.start();
+    int nlastsend = xTime.elapsed();
+
+    std::string target_str = mstrserverip+":";
+    target_str = target_str + mstrserverport ;//std::to_string()
+    auto cargs = grpc::ChannelArguments();
+    cargs.SetMaxReceiveMessageSize(1024 * 1024 * 1024); // 1 GB
+    cargs.SetMaxSendMessageSize(1024 * 1024 * 1024);
+
+    std::shared_ptr<Channel> channel = grpc::CreateCustomChannel(
+             target_str, grpc::InsecureChannelCredentials(),cargs);
+
+    std::unique_ptr<iv::group::groupservice::Stub> stub_ = iv::group::groupservice::NewStub(channel);
+
+
+    iv::group::groupRequest request;
+
+    int nid = 0;
+
+    // Container for the data we expect from the server.
+    iv::group::groupReply reply;
+
+    gpr_timespec timespec;
+      timespec.tv_sec = 30;//设置阻塞时间为2秒
+      timespec.tv_nsec = 0;
+      timespec.clock_type = GPR_TIMESPAN;
+
+ //   ClientContext context;
+
+
+
+    while(!QThread::isInterruptionRequested())
+    {
+        std::this_thread::sleep_for(std::chrono::milliseconds(1));
+        if(abs(xTime.elapsed()-nlastsend)<ninterval)
+        {
+            continue;
+        }
+
+            iv::group::vehicleinfo xmsg;
+            xmsg.set_vehicleid(mstrvehid);
+            xmsg.set_roleid(mrole);
+            qint64 nNow = QDateTime::currentMSecsSinceEpoch();
+            if((nNow - mnbrainupdate) < mnMsgValidTime)
+            {
+                iv::brain::brainstate * pbrain = new iv::brain::brainstate;
+                mMutexBrain.lock();
+                pbrain->CopyFrom(mbrainstate);
+                mMutexBrain.unlock();
+                xmsg.set_allocated_mbrainstate(pbrain);
+            }
+            if((nNow - mndecitionupdate) < mnMsgValidTime)
+            {
+                iv::brain::decition * pdecition = new iv::brain::decition;
+                mMutexDecition.lock();
+                pdecition->CopyFrom(mdecition);
+                mMutexDecition.unlock();
+                xmsg.set_allocated_mdecition(pdecition);
+            }
+            if((nNow - mngpsimuupdate) < mnMsgValidTime)
+            {
+                iv::gps::gpsimu * pgps = new iv::gps::gpsimu;
+                mMutexGPSIMU.lock();
+                pgps->CopyFrom(mgpsimu);
+                mMutexGPSIMU.unlock();
+                xmsg.set_allocated_mgpsimu(pgps);
+            }
+
+            int nbytesize = xmsg.ByteSize();
+            char * strbuf = new char[nbytesize];
+            std::shared_ptr<char> pstrbuf;
+            pstrbuf.reset(strbuf);
+            if(xmsg.SerializeToArray(strbuf,nbytesize))
+            {
+
+                ClientContext context ;
+                context.set_deadline(timespec);
+
+                request.set_strvehid(mstrvehid);
+                request.set_ngroup(mgroupid);
+                request.set_msgtime(nNow);
+                request.set_xdata(strbuf,nbytesize);
+                nid++;
+
+                nlastsend = xTime.elapsed();
+                // The actual RPC.
+                Status status = stub_->grpcgroup(&context, request, &reply);
+                if (status.ok()) {
+                    std::cout<<"  data size is "<<nbytesize<<std::endl;
+                    std::cout<<nid<<" upload successfully"<<std::endl;
+                    if(reply.nres() == 1)
+                    {
+                        iv::group::groupinfo xinfo;
+                        if(xinfo.ParseFromArray(reply.xdata().data(),reply.xdata().size()))
+                        {
+                            mpagroup->ModuleSendMsg(xinfo);
+                        }
+                    }
+                } else {
+                  std::cout << status.error_code() << ": " << status.error_message()
+                            << std::endl;
+                  std::cout<<"RPC failed"<<std::endl;
+                  if(status.error_code() == 4)
+                  {
+                      std::cout<<" RPC Exceed Time, Create New stub_"<<std::endl;
+                      channel = grpc::CreateCustomChannel(
+                               target_str, grpc::InsecureChannelCredentials(),cargs);
+
+                      stub_ = iv::group::groupservice::NewStub(channel);
+                  }
+                  std::this_thread::sleep_for(std::chrono::milliseconds(900));
+
+                }
+
+            }
+
+
+    }
+}

src/driver/driver_group_grpc_client/groupclient.h

@@ -0,0 +1,97 @@
+#ifndef GROUPCLIENT_H
+#define GROUPCLIENT_H
+
+#include <QThread>
+
+#include <QDateTime>
+
+#include <iostream>
+
+#include <vector>
+
+#include <memory>
+
+#include <QMutex>
+
+#include <thread>
+
+#include "modulecommext.h"
+
+#include <iostream>
+#include <memory>
+#include <string>
+
+#include <grpcpp/grpcpp.h>
+
+#include "grpcgroup.grpc.pb.h"
+
+#include "gpsimu.pb.h"
+#include "brainstate.pb.h"
+#include "decition.pb.h"
+#include "grpcgroup.pb.h"
+#include "groupmsg.pb.h"
+
+using grpc::Channel;
+using grpc::ClientContext;
+using grpc::Status;
+
+
+class groupclient : public QThread
+{
+public:
+    groupclient();
+
+
+private:
+    iv::modulecommext::modulecommmsg<iv::brain::brainstate> * mpabrain;
+    iv::modulecommext::modulecommmsg<iv::brain::decition> * mpadecition;
+    iv::modulecommext::modulecommmsg<iv::gps::gpsimu> * mpagpsimu;
+
+    iv::modulecommext::modulecommmsg<iv::group::groupinfo> * mpagroup;
+
+private:
+    std::string mstrbrainmsgname = "brainstate";
+    std::string mstrdecitionmsgname = "decition";
+    std::string mstrgpsimumsgname = "hcp2_gpsimu";
+    std::string mstrgroupmsgname = "groupmsg";
+
+private:
+    qint64 mnbrainupdate = 0;
+    qint64 mndecitionupdate = 0;
+    qint64 mngpsimuupdate = 0;
+
+private:
+    iv::brain::brainstate mbrainstate;
+    iv::brain::decition mdecition;
+    iv::gps::gpsimu mgpsimu;
+
+private:
+    QMutex mMutexBrain;
+    QMutex mMutexDecition;
+    QMutex mMutexGPSIMU;
+
+private:
+    void ListenBrain(google::protobuf::Message & xmsg);
+    void ListenDecition(google::protobuf::Message & xmsg);
+    void ListenGPSIMU(google::protobuf::Message & xmsg);
+
+private:
+    qint64 mnMsgValidTime = 1000;
+
+private:
+    void run();
+
+private:
+    int mnInterval = 1000;
+    std::string mstrserverip = "127.0.0.1";
+    std::string mstrserverport = "31001";
+
+private:
+    std::string mstrvehid = 0;
+    iv::group::vehicleinfo::ROLETYPE mrole = iv::group::vehicleinfo::ROLETYPE::vehicleinfo_ROLETYPE_MASTER;
+    int mgroupid = 0;  //If 0 No group
+
+
+};
+
+#endif // GROUPCLIENT_H

src/driver/driver_group_grpc_client/grpcgroup.grpc.pb.cc

@@ -0,0 +1,130 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: grpcgroup.proto
+
+#include "grpcgroup.pb.h"
+#include "grpcgroup.grpc.pb.h"
+
+#include <functional>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/channel_interface.h>
+#include <grpcpp/impl/codegen/client_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/rpc_service_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+namespace iv {
+namespace group {
+
+static const char* groupservice_method_names[] = {
+  "/iv.group.groupservice/grpcgroup",
+  "/iv.group.groupservice/queryallgroup",
+};
+
+std::unique_ptr< groupservice::Stub> groupservice::NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options) {
+  (void)options;
+  std::unique_ptr< groupservice::Stub> stub(new groupservice::Stub(channel));
+  return stub;
+}
+
+groupservice::Stub::Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel)
+  : channel_(channel), rpcmethod_grpcgroup_(groupservice_method_names[0], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  , rpcmethod_queryallgroup_(groupservice_method_names[1], ::grpc::internal::RpcMethod::NORMAL_RPC, channel)
+  {}
+
+::grpc::Status groupservice::Stub::grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::iv::group::groupReply* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::iv::group::groupRequest, ::iv::group::groupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_grpcgroup_, context, request, response);
+}
+
+void groupservice::Stub::experimental_async::grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::iv::group::groupRequest, ::iv::group::groupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_grpcgroup_, context, request, response, std::move(f));
+}
+
+void groupservice::Stub::experimental_async::grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_grpcgroup_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* groupservice::Stub::PrepareAsyncgrpcgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::iv::group::groupReply, ::iv::group::groupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_grpcgroup_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* groupservice::Stub::AsyncgrpcgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncgrpcgroupRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+::grpc::Status groupservice::Stub::queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::iv::group::groupReply* response) {
+  return ::grpc::internal::BlockingUnaryCall< ::iv::group::groupRequest, ::iv::group::groupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), rpcmethod_queryallgroup_, context, request, response);
+}
+
+void groupservice::Stub::experimental_async::queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, std::function<void(::grpc::Status)> f) {
+  ::grpc::internal::CallbackUnaryCall< ::iv::group::groupRequest, ::iv::group::groupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_queryallgroup_, context, request, response, std::move(f));
+}
+
+void groupservice::Stub::experimental_async::queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) {
+  ::grpc::internal::ClientCallbackUnaryFactory::Create< ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(stub_->channel_.get(), stub_->rpcmethod_queryallgroup_, context, request, response, reactor);
+}
+
+::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* groupservice::Stub::PrepareAsyncqueryallgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+  return ::grpc::internal::ClientAsyncResponseReaderHelper::Create< ::iv::group::groupReply, ::iv::group::groupRequest, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(channel_.get(), cq, rpcmethod_queryallgroup_, context, request);
+}
+
+::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* groupservice::Stub::AsyncqueryallgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+  auto* result =
+    this->PrepareAsyncqueryallgroupRaw(context, request, cq);
+  result->StartCall();
+  return result;
+}
+
+groupservice::Service::Service() {
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      groupservice_method_names[0],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< groupservice::Service, ::iv::group::groupRequest, ::iv::group::groupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](groupservice::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::iv::group::groupRequest* req,
+             ::iv::group::groupReply* resp) {
+               return service->grpcgroup(ctx, req, resp);
+             }, this)));
+  AddMethod(new ::grpc::internal::RpcServiceMethod(
+      groupservice_method_names[1],
+      ::grpc::internal::RpcMethod::NORMAL_RPC,
+      new ::grpc::internal::RpcMethodHandler< groupservice::Service, ::iv::group::groupRequest, ::iv::group::groupReply, ::grpc::protobuf::MessageLite, ::grpc::protobuf::MessageLite>(
+          [](groupservice::Service* service,
+             ::grpc::ServerContext* ctx,
+             const ::iv::group::groupRequest* req,
+             ::iv::group::groupReply* resp) {
+               return service->queryallgroup(ctx, req, resp);
+             }, this)));
+}
+
+groupservice::Service::~Service() {
+}
+
+::grpc::Status groupservice::Service::grpcgroup(::grpc::ServerContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+::grpc::Status groupservice::Service::queryallgroup(::grpc::ServerContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response) {
+  (void) context;
+  (void) request;
+  (void) response;
+  return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+}
+
+
+}  // namespace iv
+}  // namespace group
+

src/driver/driver_group_grpc_client/grpcgroup.grpc.pb.h

@@ -0,0 +1,510 @@
+// Generated by the gRPC C++ plugin.
+// If you make any local change, they will be lost.
+// source: grpcgroup.proto
+// Original file comments:
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+#ifndef GRPC_grpcgroup_2eproto__INCLUDED
+#define GRPC_grpcgroup_2eproto__INCLUDED
+
+#include "grpcgroup.pb.h"
+
+#include <functional>
+#include <grpc/impl/codegen/port_platform.h>
+#include <grpcpp/impl/codegen/async_generic_service.h>
+#include <grpcpp/impl/codegen/async_stream.h>
+#include <grpcpp/impl/codegen/async_unary_call.h>
+#include <grpcpp/impl/codegen/client_callback.h>
+#include <grpcpp/impl/codegen/client_context.h>
+#include <grpcpp/impl/codegen/completion_queue.h>
+#include <grpcpp/impl/codegen/message_allocator.h>
+#include <grpcpp/impl/codegen/method_handler.h>
+#include <grpcpp/impl/codegen/proto_utils.h>
+#include <grpcpp/impl/codegen/rpc_method.h>
+#include <grpcpp/impl/codegen/server_callback.h>
+#include <grpcpp/impl/codegen/server_callback_handlers.h>
+#include <grpcpp/impl/codegen/server_context.h>
+#include <grpcpp/impl/codegen/service_type.h>
+#include <grpcpp/impl/codegen/status.h>
+#include <grpcpp/impl/codegen/stub_options.h>
+#include <grpcpp/impl/codegen/sync_stream.h>
+
+namespace iv {
+namespace group {
+
+class groupservice final {
+ public:
+  static constexpr char const* service_full_name() {
+    return "iv.group.groupservice";
+  }
+  class StubInterface {
+   public:
+    virtual ~StubInterface() {}
+    virtual ::grpc::Status grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::iv::group::groupReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>> Asyncgrpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>>(AsyncgrpcgroupRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>> PrepareAsyncgrpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>>(PrepareAsyncgrpcgroupRaw(context, request, cq));
+    }
+    virtual ::grpc::Status queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::iv::group::groupReply* response) = 0;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>> Asyncqueryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>>(AsyncqueryallgroupRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>> PrepareAsyncqueryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>>(PrepareAsyncqueryallgroupRaw(context, request, cq));
+    }
+    class experimental_async_interface {
+     public:
+      virtual ~experimental_async_interface() {}
+      virtual void grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, std::function<void(::grpc::Status)>) = 0;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
+      virtual void queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, std::function<void(::grpc::Status)>) = 0;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      virtual void queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::ClientUnaryReactor* reactor) = 0;
+      #else
+      virtual void queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) = 0;
+      #endif
+    };
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    typedef class experimental_async_interface async_interface;
+    #endif
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    async_interface* async() { return experimental_async(); }
+    #endif
+    virtual class experimental_async_interface* experimental_async() { return nullptr; }
+  private:
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>* AsyncgrpcgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>* PrepareAsyncgrpcgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>* AsyncqueryallgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) = 0;
+    virtual ::grpc::ClientAsyncResponseReaderInterface< ::iv::group::groupReply>* PrepareAsyncqueryallgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) = 0;
+  };
+  class Stub final : public StubInterface {
+   public:
+    Stub(const std::shared_ptr< ::grpc::ChannelInterface>& channel);
+    ::grpc::Status grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::iv::group::groupReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>> Asyncgrpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>>(AsyncgrpcgroupRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>> PrepareAsyncgrpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>>(PrepareAsyncgrpcgroupRaw(context, request, cq));
+    }
+    ::grpc::Status queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::iv::group::groupReply* response) override;
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>> Asyncqueryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>>(AsyncqueryallgroupRaw(context, request, cq));
+    }
+    std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>> PrepareAsyncqueryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) {
+      return std::unique_ptr< ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>>(PrepareAsyncqueryallgroupRaw(context, request, cq));
+    }
+    class experimental_async final :
+      public StubInterface::experimental_async_interface {
+     public:
+      void grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, std::function<void(::grpc::Status)>) override;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void grpcgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
+      void queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, std::function<void(::grpc::Status)>) override;
+      #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      void queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::ClientUnaryReactor* reactor) override;
+      #else
+      void queryallgroup(::grpc::ClientContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response, ::grpc::experimental::ClientUnaryReactor* reactor) override;
+      #endif
+     private:
+      friend class Stub;
+      explicit experimental_async(Stub* stub): stub_(stub) { }
+      Stub* stub() { return stub_; }
+      Stub* stub_;
+    };
+    class experimental_async_interface* experimental_async() override { return &async_stub_; }
+
+   private:
+    std::shared_ptr< ::grpc::ChannelInterface> channel_;
+    class experimental_async async_stub_{this};
+    ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* AsyncgrpcgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* PrepareAsyncgrpcgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* AsyncqueryallgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) override;
+    ::grpc::ClientAsyncResponseReader< ::iv::group::groupReply>* PrepareAsyncqueryallgroupRaw(::grpc::ClientContext* context, const ::iv::group::groupRequest& request, ::grpc::CompletionQueue* cq) override;
+    const ::grpc::internal::RpcMethod rpcmethod_grpcgroup_;
+    const ::grpc::internal::RpcMethod rpcmethod_queryallgroup_;
+  };
+  static std::unique_ptr<Stub> NewStub(const std::shared_ptr< ::grpc::ChannelInterface>& channel, const ::grpc::StubOptions& options = ::grpc::StubOptions());
+
+  class Service : public ::grpc::Service {
+   public:
+    Service();
+    virtual ~Service();
+    virtual ::grpc::Status grpcgroup(::grpc::ServerContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response);
+    virtual ::grpc::Status queryallgroup(::grpc::ServerContext* context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response);
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_grpcgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_grpcgroup() {
+      ::grpc::Service::MarkMethodAsync(0);
+    }
+    ~WithAsyncMethod_grpcgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status grpcgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void Requestgrpcgroup(::grpc::ServerContext* context, ::iv::group::groupRequest* request, ::grpc::ServerAsyncResponseWriter< ::iv::group::groupReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithAsyncMethod_queryallgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithAsyncMethod_queryallgroup() {
+      ::grpc::Service::MarkMethodAsync(1);
+    }
+    ~WithAsyncMethod_queryallgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status queryallgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void Requestqueryallgroup(::grpc::ServerContext* context, ::iv::group::groupRequest* request, ::grpc::ServerAsyncResponseWriter< ::iv::group::groupReply>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  typedef WithAsyncMethod_grpcgroup<WithAsyncMethod_queryallgroup<Service > > AsyncService;
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_grpcgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_grpcgroup() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodCallback(0,
+          new ::grpc::internal::CallbackUnaryHandler< ::iv::group::groupRequest, ::iv::group::groupReply>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response) { return this->grpcgroup(context, request, response); }));}
+    void SetMessageAllocatorFor_grpcgroup(
+        ::grpc::experimental::MessageAllocator< ::iv::group::groupRequest, ::iv::group::groupReply>* allocator) {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(0);
+    #else
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::experimental().GetHandler(0);
+    #endif
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::iv::group::groupRequest, ::iv::group::groupReply>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_grpcgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status grpcgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* grpcgroup(
+      ::grpc::CallbackServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* grpcgroup(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class ExperimentalWithCallbackMethod_queryallgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithCallbackMethod_queryallgroup() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodCallback(1,
+          new ::grpc::internal::CallbackUnaryHandler< ::iv::group::groupRequest, ::iv::group::groupReply>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::iv::group::groupRequest* request, ::iv::group::groupReply* response) { return this->queryallgroup(context, request, response); }));}
+    void SetMessageAllocatorFor_queryallgroup(
+        ::grpc::experimental::MessageAllocator< ::iv::group::groupRequest, ::iv::group::groupReply>* allocator) {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::GetHandler(1);
+    #else
+      ::grpc::internal::MethodHandler* const handler = ::grpc::Service::experimental().GetHandler(1);
+    #endif
+      static_cast<::grpc::internal::CallbackUnaryHandler< ::iv::group::groupRequest, ::iv::group::groupReply>*>(handler)
+              ->SetMessageAllocator(allocator);
+    }
+    ~ExperimentalWithCallbackMethod_queryallgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status queryallgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* queryallgroup(
+      ::grpc::CallbackServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* queryallgroup(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+  typedef ExperimentalWithCallbackMethod_grpcgroup<ExperimentalWithCallbackMethod_queryallgroup<Service > > CallbackService;
+  #endif
+
+  typedef ExperimentalWithCallbackMethod_grpcgroup<ExperimentalWithCallbackMethod_queryallgroup<Service > > ExperimentalCallbackService;
+  template <class BaseClass>
+  class WithGenericMethod_grpcgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_grpcgroup() {
+      ::grpc::Service::MarkMethodGeneric(0);
+    }
+    ~WithGenericMethod_grpcgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status grpcgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithGenericMethod_queryallgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithGenericMethod_queryallgroup() {
+      ::grpc::Service::MarkMethodGeneric(1);
+    }
+    ~WithGenericMethod_queryallgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status queryallgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_grpcgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_grpcgroup() {
+      ::grpc::Service::MarkMethodRaw(0);
+    }
+    ~WithRawMethod_grpcgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status grpcgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void Requestgrpcgroup(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(0, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class WithRawMethod_queryallgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithRawMethod_queryallgroup() {
+      ::grpc::Service::MarkMethodRaw(1);
+    }
+    ~WithRawMethod_queryallgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status queryallgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    void Requestqueryallgroup(::grpc::ServerContext* context, ::grpc::ByteBuffer* request, ::grpc::ServerAsyncResponseWriter< ::grpc::ByteBuffer>* response, ::grpc::CompletionQueue* new_call_cq, ::grpc::ServerCompletionQueue* notification_cq, void *tag) {
+      ::grpc::Service::RequestAsyncUnary(1, context, request, response, new_call_cq, notification_cq, tag);
+    }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_grpcgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_grpcgroup() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodRawCallback(0,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->grpcgroup(context, request, response); }));
+    }
+    ~ExperimentalWithRawCallbackMethod_grpcgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status grpcgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* grpcgroup(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* grpcgroup(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class ExperimentalWithRawCallbackMethod_queryallgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    ExperimentalWithRawCallbackMethod_queryallgroup() {
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+      ::grpc::Service::
+    #else
+      ::grpc::Service::experimental().
+    #endif
+        MarkMethodRawCallback(1,
+          new ::grpc::internal::CallbackUnaryHandler< ::grpc::ByteBuffer, ::grpc::ByteBuffer>(
+            [this](
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+                   ::grpc::CallbackServerContext*
+    #else
+                   ::grpc::experimental::CallbackServerContext*
+    #endif
+                     context, const ::grpc::ByteBuffer* request, ::grpc::ByteBuffer* response) { return this->queryallgroup(context, request, response); }));
+    }
+    ~ExperimentalWithRawCallbackMethod_queryallgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable synchronous version of this method
+    ::grpc::Status queryallgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    #ifdef GRPC_CALLBACK_API_NONEXPERIMENTAL
+    virtual ::grpc::ServerUnaryReactor* queryallgroup(
+      ::grpc::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #else
+    virtual ::grpc::experimental::ServerUnaryReactor* queryallgroup(
+      ::grpc::experimental::CallbackServerContext* /*context*/, const ::grpc::ByteBuffer* /*request*/, ::grpc::ByteBuffer* /*response*/)
+    #endif
+      { return nullptr; }
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_grpcgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_grpcgroup() {
+      ::grpc::Service::MarkMethodStreamed(0,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::iv::group::groupRequest, ::iv::group::groupReply>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::iv::group::groupRequest, ::iv::group::groupReply>* streamer) {
+                       return this->Streamedgrpcgroup(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_grpcgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status grpcgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status Streamedgrpcgroup(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::iv::group::groupRequest,::iv::group::groupReply>* server_unary_streamer) = 0;
+  };
+  template <class BaseClass>
+  class WithStreamedUnaryMethod_queryallgroup : public BaseClass {
+   private:
+    void BaseClassMustBeDerivedFromService(const Service* /*service*/) {}
+   public:
+    WithStreamedUnaryMethod_queryallgroup() {
+      ::grpc::Service::MarkMethodStreamed(1,
+        new ::grpc::internal::StreamedUnaryHandler<
+          ::iv::group::groupRequest, ::iv::group::groupReply>(
+            [this](::grpc::ServerContext* context,
+                   ::grpc::ServerUnaryStreamer<
+                     ::iv::group::groupRequest, ::iv::group::groupReply>* streamer) {
+                       return this->Streamedqueryallgroup(context,
+                         streamer);
+                  }));
+    }
+    ~WithStreamedUnaryMethod_queryallgroup() override {
+      BaseClassMustBeDerivedFromService(this);
+    }
+    // disable regular version of this method
+    ::grpc::Status queryallgroup(::grpc::ServerContext* /*context*/, const ::iv::group::groupRequest* /*request*/, ::iv::group::groupReply* /*response*/) override {
+      abort();
+      return ::grpc::Status(::grpc::StatusCode::UNIMPLEMENTED, "");
+    }
+    // replace default version of method with streamed unary
+    virtual ::grpc::Status Streamedqueryallgroup(::grpc::ServerContext* context, ::grpc::ServerUnaryStreamer< ::iv::group::groupRequest,::iv::group::groupReply>* server_unary_streamer) = 0;
+  };
+  typedef WithStreamedUnaryMethod_grpcgroup<WithStreamedUnaryMethod_queryallgroup<Service > > StreamedUnaryService;
+  typedef Service SplitStreamedService;
+  typedef WithStreamedUnaryMethod_grpcgroup<WithStreamedUnaryMethod_queryallgroup<Service > > StreamedService;
+};
+
+}  // namespace group
+}  // namespace iv
+
+
+#endif  // GRPC_grpcgroup_2eproto__INCLUDED

src/driver/driver_group_grpc_client/main.cpp

@@ -0,0 +1,11 @@
+#include <QCoreApplication>
+
+int gnGroupID = 1;  //if 0 no group
+std::string gstrVehid = "demo";
+
+int main(int argc, char *argv[])
+{
+    QCoreApplication a(argc, argv);
+
+    return a.exec();
+}

src/driver/driver_group_grpc_client/prototocpp.txt

@@ -0,0 +1,3 @@
+protoc -I=./../../include/proto3 --plugin=protoc-gen-grpc=/home/yuchuli/git/grpc-framework/build2/grpc_cpp_plugin --grpc_out=. ./../../include/proto3/grpcgroup.proto
+
+protoc -I=./../../include/proto3 --cpp_out=./../../include/msgtype   ./../../include/proto3/grpcgroup.proto

src/include/proto/groupmsg.proto

@@ -0,0 +1,28 @@
+syntax = "proto2";
+
+package iv.group;
+
+import "brainstate.proto";
+import "decition.proto";
+import "gpsimu.proto";
+
+message vehicleinfo
+{
+	enum ROLETYPE
+	{
+		MASTER = 0;
+		SLAVE = 1;
+	}
+	required string vehicleid = 1;
+	required ROLETYPE  roleid = 2;  
+	optional iv.brain.brainstate mbrainstate =3 ;
+	optional iv.brain.decition mdecition = 4;
+	optional iv.gps.gpsimu mgpsimu = 5;
+	optional int32  groupid = 6;
+}
+
+
+message groupinfo
+{
+	repeated vehicleinfo mvehinfo = 1;
+}

src/include/proto3/grpcgroup.proto

@@ -0,0 +1,47 @@
+// Copyright 2015 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+option java_multiple_files = true;
+option java_package = "io.grpc.adc.grpcgroup";
+option java_outer_classname = "grpcgroup";
+option objc_class_prefix = "HLW";
+
+package iv.group;
+
+
+service groupservice {
+
+  rpc grpcgroup (groupRequest) returns (groupReply) {}
+  rpc queryallgroup (groupRequest) returns (groupReply) {}
+  
+}
+
+
+message groupRequest {
+
+    string strvehid = 1;
+    int32  ngroup = 2;
+    int64 msgtime = 3;
+    bytes xdata = 4;
+}
+
+// The response message containing the greetings
+message groupReply {
+  int32 nres = 1;  
+  int32  ngroup = 2;
+  bytes xdata = 3;
+//  string message = 1;
+}