VptServer多线程支持

pansen

2019-04-11 ad716fb9f1e8ae5cde818be423ca47225a4ff4ec

VptServer多线程支持

 QiaoJiaSystem/VptServer/CMakeLists.txt

@@ -112,3 +112,14 @@
target_link_libraries(${PROJECT_NAME}
    ${LIBS}
    )


add_executable(${PROJECT_NAME}demo
    #    testmain.cpp
    demo.cpp
    ${SOURCES}
    )

target_link_libraries(${PROJECT_NAME}demo
    ${LIBS}
    )

 QiaoJiaSystem/VptServer/VptDetectWrapper.cpp

@@ -20,6 +20,7 @@

void VptDetectWrapper::init() {
    m_param.mode = DEVICE_GPU;
#if 0
    m_param.gpuid = m_gpuIdx;
    m_param.hp_recg_config = SY_CONFIG_OPEN;
    m_param.hcp_recg_config = SY_CONFIG_OPEN;
@@ -28,6 +29,16 @@
    m_param.vehicle_pendant_det_recg_config = SY_CONFIG_OPEN;
    m_param.dbPath = const_cast<char *>(m_dbFilePath.data());
    m_param.log = SY_CONFIG_OPEN;
#else
    m_param.gpuid = m_gpuIdx;
    m_param.hp_recg_config = SY_CONFIG_CLOSE;
    m_param.hcp_recg_config = SY_CONFIG_CLOSE;
    m_param.vehicle_color_config = SY_CONFIG_CLOSE;
    m_param.vehicle_recg_config = SY_CONFIG_CLOSE;
    m_param.vehicle_pendant_det_recg_config = SY_CONFIG_CLOSE;
    m_param.dbPath = const_cast<char *>(m_dbFilePath.data());
    m_param.log = SY_CONFIG_CLOSE;
#endif
    vpt_pic_init(&m_handle, m_param);
}


 QiaoJiaSystem/VptServer/VptServerI.cpp

@@ -9,13 +9,25 @@
VptServerI::VptServerI() {}

VptServerI::~VptServerI() {

    for (auto item_ptr : m_map_vptDetectWrapper) {
        if (item_ptr.second != nullptr) {
            delete item_ptr.second;
            item_ptr.second = nullptr;
        }
        m_map_vptDetectWrapper.erase(item_ptr.first);
    }
}

VptDetect::ObjInfos
VptServerI::VptDetect(Ice::Int width, Ice::Int height, const ::std::string &shM,
                      const ::Ice::Current &current) {

    thread::id key = std::this_thread::get_id();
    if (m_map_vptDetectWrapper.find(key) == m_map_vptDetectWrapper.end()) {
        m_map_vptDetectWrapper[key] = new VptDetectWrapper();
    }
    VptDetectWrapper &m_vptDetectWrapper = *m_map_vptDetectWrapper[key];

    VptDetect::ObjInfos objInfos;
    QSharedMemory shareMemory(QString(shM.c_str()));
    if (shareMemory.attach()) {

 QiaoJiaSystem/VptServer/VptServerI.h

@@ -10,6 +10,9 @@
#define QIAOJIASYSTEM_VPTSERVERI_H


#include <pthread.h>
#include <thread>

class VptServerI : public VptDetect::VptDetectServer {
public:
    VptServerI();
@@ -34,7 +37,8 @@
    cv::Mat bufferToMat(const int w, const int h, const int channels, const void *buffer);

private:
    VptDetectWrapper m_vptDetectWrapper;
    std::map<std::thread::id, VptDetectWrapper *> m_map_vptDetectWrapper;
//    VptDetectWrapper m_vptDetectWrapper;
};



 QiaoJiaSystem/VptServer/demo.cpp

New file
@@ -0,0 +1,116 @@
//
// Created by ps on 19-4-11.
//
#include "vpt_pic.h"
//#include <highgui.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include <fstream>
#include <string>
#include "sy_common.h"
#include "mainAssist.h"

#ifdef _WIN32
#include<windows.h>
#else

#include <sys/time.h>

#endif

#include <basic/util/app/AppUtil.h>
#include <Ice/Ice.h>
#include <basic/rpc/IceRpc.hpp>
#include <basic/util/app/AppPreference.hpp>
#include <basic/debug/Debug.h>

#include <basic/util/app/AppConfig.h>
#include <QtCore/QSharedMemory>
#include "rpc/VptServer.h"

int main(int argc, char **argv) {
    string imgpath;

    if (argc < 2) {
        printf("Parameter number not right.\n");
        return 0;
    } else {
        imgpath = argv[1];
    }

    IceRpcClient<VptDetect::VptDetectServerPrx> rpcClient("vptServer", "", 12003, "tcp");

    auto server = rpcClient.getServer();
    std::string shareMemoryName = "vptServer";
    QSharedMemory *sharedMemory = new QSharedMemory(QString(shareMemoryName.c_str()));
    //1520 x 2688   1080 x 1920 //2560 * 1440 * 4
    if (!sharedMemory->create(4608 * 2592 * 4)) {
        sharedMemory->attach();
    }

//    server->getStr(1);

    CvFont font;
    cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX, 1.0, 1.0, 0, 1, 3);
    int fontFace = CV_FONT_HERSHEY_COMPLEX;
    double fontScale = 1;
    int thickness = 2;


    cv::VideoCapture capture;
    capture.open(imgpath);

    cv::Mat process_image;
    capture >> process_image;//读出每一帧的图像

    cv::Mat image;

    while (!process_image.empty()) {

        image = cv::Mat(process_image.rows, process_image.cols, CV_8UC3, sharedMemory->data());
        process_image.copyTo(image);

        auto res = server->VptDetect(image.cols, image.rows, sharedMemory->key().toStdString());
        DBG(res.size());

//        for (int i = 0; i < result.count; i++) {
//            char str_i[100];
//            int colorIndex = result.info[i].obj_index;
//            if (colorIndex < 0 || colorIndex >= 9)continue;
//            sprintf(str_i, "%s:%.2f", type[colorIndex].c_str(), result.info[i].obj_score);
//
//            rectangle(process_image,
//                      cvPoint(result.info[i].obj_rect.left_ - 5, result.info[i].obj_rect.top_ - 15),
//                      cvPoint(result.info[i].obj_rect.left_ + result.info[i].obj_rect.width_ + 5,
//                              result.info[i].obj_rect.top_ + result.info[i].obj_rect.height_ + 10),
//                      cv::Scalar(color[colorIndex][0], color[colorIndex][1], color[colorIndex][2]), 3, 1);
//
//            cv::putText(process_image, str_i,
//                        cv::Point(result.info[i].obj_rect.left_, result.info[i].obj_rect.top_),
//                        fontFace, fontScale,
//                        cv::Scalar(color[colorIndex][0], color[colorIndex][1], color[colorIndex][2]), thickness, 8);
//
//            //输出二次属性分析结果
//            printfAnalysisRes(colorIndex, result.info[i].analysis_res);
//        }

#ifdef _MSC_VER
        cv::imshow("res", image);
        cv::waitKey(0);
#else
//        char svpath[1024];
//        memset(svpath, 0, sizeof(svpath));
//        std::string strNewTime2 = AppUtil::getTimeUSecString();
//        strNewTime2.append(".jpg");
//
//        sprintf(svpath, "vpt_res/%s", strNewTime2.c_str());
//        imwrite(svpath, process_image);
#endif

        capture >> process_image;//读出每一帧的图像
    }


    return 0;
}


 QiaoJiaSystem/VptServer/main.cpp

@@ -48,8 +48,8 @@

    IceRpcServer<VptServerI> server("vptServer", appPref.getIntData("RpcVptPort"), "tcp");
    server.setMessageSizeMax(1024 * 1024 * 50);
    server.setPoolInitSize(5);
    server.setPoolMaxSize(10);
    server.setPoolInitSize(1);
    server.setPoolMaxSize(3);
    server.runWaitShutDown();
    return 0;
}

 QiaoJiaSystem/VptServer/rpc/VptServer.h

@@ -475,1254 +475,1275 @@

#else // C++98 mapping

namespace IceProxy
{
namespace IceProxy {

namespace VptDetect
{
    namespace VptDetect {

class VptDetectServer;
void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::VptDetect::VptDetectServer>&);
::IceProxy::Ice::Object* upCast(::IceProxy::VptDetect::VptDetectServer*);
        class VptDetectServer;

        void _readProxy(::Ice::InputStream *, ::IceInternal::ProxyHandle<::IceProxy::VptDetect::VptDetectServer> &);

        ::IceProxy::Ice::Object *upCast(::IceProxy::VptDetect::VptDetectServer *);

    }

}

}
namespace VptDetect {

namespace VptDetect
{
    class VptDetectServer;

class VptDetectServer;
::Ice::Object* upCast(::VptDetect::VptDetectServer*);
typedef ::IceInternal::Handle< ::VptDetect::VptDetectServer> VptDetectServerPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::VptDetect::VptDetectServer> VptDetectServerPrx;
typedef VptDetectServerPrx VptDetectServerPrxPtr;
void _icePatchObjectPtr(VptDetectServerPtr&, const ::Ice::ObjectPtr&);
    ::Ice::Object *upCast(::VptDetect::VptDetectServer *);

    typedef ::IceInternal::Handle<::VptDetect::VptDetectServer> VptDetectServerPtr;
    typedef ::IceInternal::ProxyHandle<::IceProxy::VptDetect::VptDetectServer> VptDetectServerPrx;
    typedef VptDetectServerPrx VptDetectServerPrxPtr;

    void _icePatchObjectPtr(VptDetectServerPtr &, const ::Ice::ObjectPtr &);

}

namespace VptDetect
{
namespace VptDetect {

struct RECT
{
    ::Ice::Float left;
    ::Ice::Float top;
    ::Ice::Float width;
    ::Ice::Float height;
};
    struct RECT {
        ::Ice::Float left;
        ::Ice::Float top;
        ::Ice::Float width;
        ::Ice::Float height;
    };

struct ClassfyObjRes
{
    ::Ice::Int res_index;
    ::Ice::Float res_prob;
};
    struct ClassfyObjRes {
        ::Ice::Int res_index;
        ::Ice::Float res_prob;
    };

typedef ::std::vector< ::VptDetect::ClassfyObjRes> ResObjs;
    typedef ::std::vector<::VptDetect::ClassfyObjRes> ResObjs;

struct PersonDetectRes
{
    ::VptDetect::ResObjs res_objs;
};
    struct PersonDetectRes {
        ::VptDetect::ResObjs res_objs;
    };

struct PerRideCarDetectRes
{
    ::VptDetect::ResObjs res_objs;
};
    struct PerRideCarDetectRes {
        ::VptDetect::ResObjs res_objs;
    };

struct CarDetectRes
{
    ::std::string vehicle_brand;
    ::std::string vehicle_subbrand;
    ::std::string vehicle_issue_year;
    ::std::string vehicle_type;
    ::std::string freight_ton;
    ::Ice::Float vehicle_score;
    ::Ice::Int colorLabel;
    ::Ice::Float colorLabelProb;
    ::VptDetect::RECT carPlateRect;
    ::Ice::Float carPlateRectScore;
    ::std::string carPlate;
    ::Ice::Float carPlateScore;
    ::Ice::Int carPlatetype;
};
    struct CarDetectRes {
        ::std::string vehicle_brand;
        ::std::string vehicle_subbrand;
        ::std::string vehicle_issue_year;
        ::std::string vehicle_type;
        ::std::string freight_ton;
        ::Ice::Float vehicle_score;
        ::Ice::Int colorLabel;
        ::Ice::Float colorLabelProb;
        ::VptDetect::RECT carPlateRect;
        ::Ice::Float carPlateRectScore;
        ::std::string carPlate;
        ::Ice::Float carPlateScore;
        ::Ice::Int carPlatetype;
    };

struct VptDetectResult
{
    ::Ice::Int sdkDetectType;
    ::VptDetect::RECT bskRect;
    ::VptDetect::PersonDetectRes personDetectRes;
    ::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
    ::VptDetect::CarDetectRes carDetectRes;
};
    struct VptDetectResult {
        ::Ice::Int sdkDetectType;
        ::VptDetect::RECT bskRect;
        ::VptDetect::PersonDetectRes personDetectRes;
        ::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
        ::VptDetect::CarDetectRes carDetectRes;
    };

typedef ::std::vector< ::VptDetect::VptDetectResult> ObjInfos;
    typedef ::std::vector<::VptDetect::VptDetectResult> ObjInfos;

typedef ::std::vector< ::std::string> stringData;
    typedef ::std::vector<::std::string> stringData;

typedef ::std::vector< ::VptDetect::stringData> stringDatas;
    typedef ::std::vector<::VptDetect::stringData> stringDatas;

}

namespace VptDetect
{
namespace VptDetect {

class Callback_VptDetectServer_VptDetect_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_VptDetect_Base> Callback_VptDetectServer_VptDetectPtr;
    class Callback_VptDetectServer_VptDetect_Base : public virtual ::IceInternal::CallbackBase {
    };

class Callback_VptDetectServer_getStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;
    typedef ::IceUtil::Handle<Callback_VptDetectServer_VptDetect_Base> Callback_VptDetectServer_VptDetectPtr;

class Callback_VptDetectServer_getTypeStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getTypeStr_Base> Callback_VptDetectServer_getTypeStrPtr;
    class Callback_VptDetectServer_getStr_Base : public virtual ::IceInternal::CallbackBase {
    };

class Callback_VptDetectServer_getColorLabel_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getColorLabel_Base> Callback_VptDetectServer_getColorLabelPtr;
    typedef ::IceUtil::Handle<Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;

class Callback_VptDetectServer_getHpResStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getHpResStr_Base> Callback_VptDetectServer_getHpResStrPtr;
    class Callback_VptDetectServer_getTypeStr_Base : public virtual ::IceInternal::CallbackBase {
    };

class Callback_VptDetectServer_getHcpResStr_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_VptDetectServer_getHcpResStr_Base> Callback_VptDetectServer_getHcpResStrPtr;
    typedef ::IceUtil::Handle<Callback_VptDetectServer_getTypeStr_Base> Callback_VptDetectServer_getTypeStrPtr;

    class Callback_VptDetectServer_getColorLabel_Base : public virtual ::IceInternal::CallbackBase {
    };

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getColorLabel_Base> Callback_VptDetectServer_getColorLabelPtr;

    class Callback_VptDetectServer_getHpResStr_Base : public virtual ::IceInternal::CallbackBase {
    };

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getHpResStr_Base> Callback_VptDetectServer_getHpResStrPtr;

    class Callback_VptDetectServer_getHcpResStr_Base : public virtual ::IceInternal::CallbackBase {
    };

    typedef ::IceUtil::Handle<Callback_VptDetectServer_getHcpResStr_Base> Callback_VptDetectServer_getHcpResStrPtr;

}

namespace IceProxy
{
namespace IceProxy {

namespace VptDetect
{
    namespace VptDetect {

class VptDetectServer : public virtual ::Ice::Proxy<VptDetectServer, ::IceProxy::Ice::Object>
{
public:
        class VptDetectServer : public virtual ::Ice::Proxy<VptDetectServer, ::IceProxy::Ice::Object> {
        public:

    ::VptDetect::ObjInfos VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_VptDetect(_iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, ::IceInternal::dummyCallback, 0, true));
            ::VptDetect::ObjInfos
            VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                      const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_VptDetect(_iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context,
                                                           ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context,
                                             ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del,
                                             cookie);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                            const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::VptDetect::Callback_VptDetectServer_VptDetectPtr &del,
                            const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del,
                                             cookie);
            }

            ::Ice::AsyncResultPtr
            begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
                            const ::Ice::Context &context,
                            const ::VptDetect::Callback_VptDetectServer_VptDetectPtr &del,
                            const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
            }

            ::VptDetect::ObjInfos end_VptDetect(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_VptDetect(::Ice::Int, ::Ice::Int, const ::std::string &, const ::Ice::Context &,
                                  const ::IceInternal::CallbackBasePtr &, const ::Ice::LocalObjectPtr &cookie = 0,
                                  bool sync = false);

        public:

            ::VptDetect::stringDatas
            getStr(::Ice::Int iceP_type, const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getStr(_iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                         const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, context, del, cookie);
            }

            ::Ice::AsyncResultPtr
            begin_getStr(::Ice::Int iceP_type, const ::VptDetect::Callback_VptDetectServer_getStrPtr &del,
                         const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context &context,
                                               const ::VptDetect::Callback_VptDetectServer_getStrPtr &del,
                                               const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getStr(iceP_type, context, del, cookie);
            }

            ::VptDetect::stringDatas end_getStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getStr(::Ice::Int, const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                               const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringData getTypeStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getTypeStr(_iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getTypeStr(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                   const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr &del,
                                                   const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context &context,
                                                   const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr &del,
                                                   const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getTypeStr(context, del, cookie);
            }

            ::VptDetect::stringData end_getTypeStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr _iceI_begin_getTypeStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                                         const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringData getColorLabel(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getColorLabel(_iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getColorLabel(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                      const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr &del,
                                                      const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context &context,
                                                      const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr &del,
                                                      const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getColorLabel(context, del, cookie);
            }

            ::VptDetect::stringData end_getColorLabel(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getColorLabel(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                      const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringDatas getHpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getHpResStr(_iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getHpResStr(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                    const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr &del,
                                                    const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context &context,
                                                    const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr &del,
                                                    const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHpResStr(context, del, cookie);
            }

            ::VptDetect::stringDatas end_getHpResStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getHpResStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                    const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            ::VptDetect::stringDatas getHcpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return end_getHcpResStr(_iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0, true));
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context &context = ::Ice::noExplicitContext) {
                return _iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0);
            }

            ::Ice::AsyncResultPtr
            begin_getHcpResStr(const ::Ice::CallbackPtr &del, const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context &context, const ::Ice::CallbackPtr &del,
                                                     const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(context, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr &del,
                                                     const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
            }

            ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context &context,
                                                     const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr &del,
                                                     const ::Ice::LocalObjectPtr &cookie = 0) {
                return _iceI_begin_getHcpResStr(context, del, cookie);
            }

            ::VptDetect::stringDatas end_getHcpResStr(const ::Ice::AsyncResultPtr &);

        private:

            ::Ice::AsyncResultPtr
            _iceI_begin_getHcpResStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
                                     const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);

        public:

            static const ::std::string &ice_staticId();

        protected:

            virtual ::IceProxy::Ice::Object *_newInstance() const;
        };

    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::VptDetect::Callback_VptDetectServer_VptDetectPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_VptDetectPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context, del, cookie);
    }

    ::VptDetect::ObjInfos end_VptDetect(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_VptDetect(::Ice::Int, ::Ice::Int, const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringDatas getStr(::Ice::Int iceP_type, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getStr(_iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getStr(iceP_type, context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::VptDetect::Callback_VptDetectServer_getStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, ::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getStr(::Ice::Int iceP_type, const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getStr(iceP_type, context, del, cookie);
    }

    ::VptDetect::stringDatas end_getStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getStr(::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringData getTypeStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getTypeStr(_iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getTypeStr(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getTypeStr(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getTypeStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTypeStr(context, del, cookie);
    }

    ::VptDetect::stringData end_getTypeStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getTypeStr(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringData getColorLabel(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getColorLabel(_iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getColorLabel(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getColorLabel(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getColorLabelPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getColorLabel(context, del, cookie);
    }

    ::VptDetect::stringData end_getColorLabel(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getColorLabel(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringDatas getHpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getHpResStr(_iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getHpResStr(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHpResStr(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getHpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHpResStr(context, del, cookie);
    }

    ::VptDetect::stringDatas end_getHpResStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getHpResStr(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    ::VptDetect::stringDatas getHcpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getHcpResStr(_iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0, true));
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getHcpResStr(context, ::IceInternal::dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(context, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(::Ice::noExplicitContext, del, cookie);
    }

    ::Ice::AsyncResultPtr begin_getHcpResStr(const ::Ice::Context& context, const ::VptDetect::Callback_VptDetectServer_getHcpResStrPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getHcpResStr(context, del, cookie);
    }

    ::VptDetect::stringDatas end_getHcpResStr(const ::Ice::AsyncResultPtr&);

private:

    ::Ice::AsyncResultPtr _iceI_begin_getHcpResStr(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);

public:

    static const ::std::string& ice_staticId();

protected:

    virtual ::IceProxy::Ice::Object* _newInstance() const;
};

}

}
namespace VptDetect {

namespace VptDetect
{
    class VptDetectServer : public virtual ::Ice::Object {
    public:

class VptDetectServer : public virtual ::Ice::Object
{
public:
        typedef VptDetectServerPrx ProxyType;
        typedef VptDetectServerPtr PointerType;

    typedef VptDetectServerPrx ProxyType;
    typedef VptDetectServerPtr PointerType;
        virtual ~VptDetectServer();

    virtual ~VptDetectServer();
        virtual bool ice_isA(const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) const;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::emptyCurrent) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::emptyCurrent) const;
        virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current & = ::Ice::emptyCurrent) const;

    static const ::std::string& ice_staticId();
        virtual const ::std::string &ice_id(const ::Ice::Current & = ::Ice::emptyCurrent) const;

    virtual ::VptDetect::ObjInfos VptDetect(::Ice::Int, ::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_VptDetect(::IceInternal::Incoming&, const ::Ice::Current&);
        static const ::std::string &ice_staticId();

    virtual ::VptDetect::stringDatas getStr(::Ice::Int, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getStr(::IceInternal::Incoming&, const ::Ice::Current&);
        virtual ::VptDetect::ObjInfos
        VptDetect(::Ice::Int, ::Ice::Int, const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

    virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getTypeStr(::IceInternal::Incoming&, const ::Ice::Current&);
        bool _iceD_VptDetect(::IceInternal::Incoming &, const ::Ice::Current &);

    virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getColorLabel(::IceInternal::Incoming&, const ::Ice::Current&);
        virtual ::VptDetect::stringDatas getStr(::Ice::Int, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

    virtual ::VptDetect::stringDatas getHpResStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getHpResStr(::IceInternal::Incoming&, const ::Ice::Current&);
        bool _iceD_getStr(::IceInternal::Incoming &, const ::Ice::Current &);

    virtual ::VptDetect::stringDatas getHcpResStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
    bool _iceD_getHcpResStr(::IceInternal::Incoming&, const ::Ice::Current&);
        virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
        bool _iceD_getTypeStr(::IceInternal::Incoming &, const ::Ice::Current &);

protected:
        virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

    virtual void _iceWriteImpl(::Ice::OutputStream*) const;
    virtual void _iceReadImpl(::Ice::InputStream*);
};
        bool _iceD_getColorLabel(::IceInternal::Incoming &, const ::Ice::Current &);

inline bool operator==(const VptDetectServer& lhs, const VptDetectServer& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
}
        virtual ::VptDetect::stringDatas getHpResStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

inline bool operator<(const VptDetectServer& lhs, const VptDetectServer& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
}
        bool _iceD_getHpResStr(::IceInternal::Incoming &, const ::Ice::Current &);

        virtual ::VptDetect::stringDatas getHcpResStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

        bool _iceD_getHcpResStr(::IceInternal::Incoming &, const ::Ice::Current &);

        virtual bool _iceDispatch(::IceInternal::Incoming &, const ::Ice::Current &);

    protected:

        virtual void _iceWriteImpl(::Ice::OutputStream *) const;

        virtual void _iceReadImpl(::Ice::InputStream *);
    };

    inline bool operator==(const VptDetectServer &lhs, const VptDetectServer &rhs) {
        return static_cast<const ::Ice::Object &>(lhs) == static_cast<const ::Ice::Object &>(rhs);
    }

    inline bool operator<(const VptDetectServer &lhs, const VptDetectServer &rhs) {
        return static_cast<const ::Ice::Object &>(lhs) < static_cast<const ::Ice::Object &>(rhs);
    }

}

namespace Ice
{
namespace Ice {

template<>
struct StreamableTraits< ::VptDetect::RECT>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 16;
    static const bool fixedLength = true;
};
    template<>
    struct StreamableTraits<::VptDetect::RECT> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 16;
        static const bool fixedLength = true;
    };

template<typename S>
struct StreamWriter< ::VptDetect::RECT, S>
{
    static void write(S* ostr, const ::VptDetect::RECT& v)
    {
        ostr->write(v.left);
        ostr->write(v.top);
        ostr->write(v.width);
        ostr->write(v.height);
    }
};
    template<typename S>
    struct StreamWriter<::VptDetect::RECT, S> {
        static void write(S *ostr, const ::VptDetect::RECT &v) {
            ostr->write(v.left);
            ostr->write(v.top);
            ostr->write(v.width);
            ostr->write(v.height);
        }
    };

template<typename S>
struct StreamReader< ::VptDetect::RECT, S>
{
    static void read(S* istr, ::VptDetect::RECT& v)
    {
        istr->read(v.left);
        istr->read(v.top);
        istr->read(v.width);
        istr->read(v.height);
    }
};
    template<typename S>
    struct StreamReader<::VptDetect::RECT, S> {
        static void read(S *istr, ::VptDetect::RECT &v) {
            istr->read(v.left);
            istr->read(v.top);
            istr->read(v.width);
            istr->read(v.height);
        }
    };

template<>
struct StreamableTraits< ::VptDetect::ClassfyObjRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 8;
    static const bool fixedLength = true;
};
    template<>
    struct StreamableTraits<::VptDetect::ClassfyObjRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 8;
        static const bool fixedLength = true;
    };

template<typename S>
struct StreamWriter< ::VptDetect::ClassfyObjRes, S>
{
    static void write(S* ostr, const ::VptDetect::ClassfyObjRes& v)
    {
        ostr->write(v.res_index);
        ostr->write(v.res_prob);
    }
};
    template<typename S>
    struct StreamWriter<::VptDetect::ClassfyObjRes, S> {
        static void write(S *ostr, const ::VptDetect::ClassfyObjRes &v) {
            ostr->write(v.res_index);
            ostr->write(v.res_prob);
        }
    };

template<typename S>
struct StreamReader< ::VptDetect::ClassfyObjRes, S>
{
    static void read(S* istr, ::VptDetect::ClassfyObjRes& v)
    {
        istr->read(v.res_index);
        istr->read(v.res_prob);
    }
};
    template<typename S>
    struct StreamReader<::VptDetect::ClassfyObjRes, S> {
        static void read(S *istr, ::VptDetect::ClassfyObjRes &v) {
            istr->read(v.res_index);
            istr->read(v.res_prob);
        }
    };

template<>
struct StreamableTraits< ::VptDetect::PersonDetectRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 1;
    static const bool fixedLength = false;
};
    template<>
    struct StreamableTraits<::VptDetect::PersonDetectRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };

template<typename S>
struct StreamWriter< ::VptDetect::PersonDetectRes, S>
{
    static void write(S* ostr, const ::VptDetect::PersonDetectRes& v)
    {
        ostr->write(v.res_objs);
    }
};
    template<typename S>
    struct StreamWriter<::VptDetect::PersonDetectRes, S> {
        static void write(S *ostr, const ::VptDetect::PersonDetectRes &v) {
            ostr->write(v.res_objs);
        }
    };

template<typename S>
struct StreamReader< ::VptDetect::PersonDetectRes, S>
{
    static void read(S* istr, ::VptDetect::PersonDetectRes& v)
    {
        istr->read(v.res_objs);
    }
};
    template<typename S>
    struct StreamReader<::VptDetect::PersonDetectRes, S> {
        static void read(S *istr, ::VptDetect::PersonDetectRes &v) {
            istr->read(v.res_objs);
        }
    };

template<>
struct StreamableTraits< ::VptDetect::PerRideCarDetectRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 1;
    static const bool fixedLength = false;
};
    template<>
    struct StreamableTraits<::VptDetect::PerRideCarDetectRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };

template<typename S>
struct StreamWriter< ::VptDetect::PerRideCarDetectRes, S>
{
    static void write(S* ostr, const ::VptDetect::PerRideCarDetectRes& v)
    {
        ostr->write(v.res_objs);
    }
};
    template<typename S>
    struct StreamWriter<::VptDetect::PerRideCarDetectRes, S> {
        static void write(S *ostr, const ::VptDetect::PerRideCarDetectRes &v) {
            ostr->write(v.res_objs);
        }
    };

template<typename S>
struct StreamReader< ::VptDetect::PerRideCarDetectRes, S>
{
    static void read(S* istr, ::VptDetect::PerRideCarDetectRes& v)
    {
        istr->read(v.res_objs);
    }
};
    template<typename S>
    struct StreamReader<::VptDetect::PerRideCarDetectRes, S> {
        static void read(S *istr, ::VptDetect::PerRideCarDetectRes &v) {
            istr->read(v.res_objs);
        }
    };

template<>
struct StreamableTraits< ::VptDetect::CarDetectRes>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 46;
    static const bool fixedLength = false;
};
    template<>
    struct StreamableTraits<::VptDetect::CarDetectRes> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 46;
        static const bool fixedLength = false;
    };

template<typename S>
struct StreamWriter< ::VptDetect::CarDetectRes, S>
{
    static void write(S* ostr, const ::VptDetect::CarDetectRes& v)
    {
        ostr->write(v.vehicle_brand);
        ostr->write(v.vehicle_subbrand);
        ostr->write(v.vehicle_issue_year);
        ostr->write(v.vehicle_type);
        ostr->write(v.freight_ton);
        ostr->write(v.vehicle_score);
        ostr->write(v.colorLabel);
        ostr->write(v.colorLabelProb);
        ostr->write(v.carPlateRect);
        ostr->write(v.carPlateRectScore);
        ostr->write(v.carPlate);
        ostr->write(v.carPlateScore);
        ostr->write(v.carPlatetype);
    }
};
    template<typename S>
    struct StreamWriter<::VptDetect::CarDetectRes, S> {
        static void write(S *ostr, const ::VptDetect::CarDetectRes &v) {
            ostr->write(v.vehicle_brand);
            ostr->write(v.vehicle_subbrand);
            ostr->write(v.vehicle_issue_year);
            ostr->write(v.vehicle_type);
            ostr->write(v.freight_ton);
            ostr->write(v.vehicle_score);
            ostr->write(v.colorLabel);
            ostr->write(v.colorLabelProb);
            ostr->write(v.carPlateRect);
            ostr->write(v.carPlateRectScore);
            ostr->write(v.carPlate);
            ostr->write(v.carPlateScore);
            ostr->write(v.carPlatetype);
        }
    };

template<typename S>
struct StreamReader< ::VptDetect::CarDetectRes, S>
{
    static void read(S* istr, ::VptDetect::CarDetectRes& v)
    {
        istr->read(v.vehicle_brand);
        istr->read(v.vehicle_subbrand);
        istr->read(v.vehicle_issue_year);
        istr->read(v.vehicle_type);
        istr->read(v.freight_ton);
        istr->read(v.vehicle_score);
        istr->read(v.colorLabel);
        istr->read(v.colorLabelProb);
        istr->read(v.carPlateRect);
        istr->read(v.carPlateRectScore);
        istr->read(v.carPlate);
        istr->read(v.carPlateScore);
        istr->read(v.carPlatetype);
    }
};
    template<typename S>
    struct StreamReader<::VptDetect::CarDetectRes, S> {
        static void read(S *istr, ::VptDetect::CarDetectRes &v) {
            istr->read(v.vehicle_brand);
            istr->read(v.vehicle_subbrand);
            istr->read(v.vehicle_issue_year);
            istr->read(v.vehicle_type);
            istr->read(v.freight_ton);
            istr->read(v.vehicle_score);
            istr->read(v.colorLabel);
            istr->read(v.colorLabelProb);
            istr->read(v.carPlateRect);
            istr->read(v.carPlateRectScore);
            istr->read(v.carPlate);
            istr->read(v.carPlateScore);
            istr->read(v.carPlatetype);
        }
    };

template<>
struct StreamableTraits< ::VptDetect::VptDetectResult>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 68;
    static const bool fixedLength = false;
};
    template<>
    struct StreamableTraits<::VptDetect::VptDetectResult> {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 68;
        static const bool fixedLength = false;
    };

template<typename S>
struct StreamWriter< ::VptDetect::VptDetectResult, S>
{
    static void write(S* ostr, const ::VptDetect::VptDetectResult& v)
    {
        ostr->write(v.sdkDetectType);
        ostr->write(v.bskRect);
        ostr->write(v.personDetectRes);
        ostr->write(v.perRideCarDetectRes);
        ostr->write(v.carDetectRes);
    }
};
    template<typename S>
    struct StreamWriter<::VptDetect::VptDetectResult, S> {
        static void write(S *ostr, const ::VptDetect::VptDetectResult &v) {
            ostr->write(v.sdkDetectType);
            ostr->write(v.bskRect);
            ostr->write(v.personDetectRes);
            ostr->write(v.perRideCarDetectRes);
            ostr->write(v.carDetectRes);
        }
    };

template<typename S>
struct StreamReader< ::VptDetect::VptDetectResult, S>
{
    static void read(S* istr, ::VptDetect::VptDetectResult& v)
    {
        istr->read(v.sdkDetectType);
        istr->read(v.bskRect);
        istr->read(v.personDetectRes);
        istr->read(v.perRideCarDetectRes);
        istr->read(v.carDetectRes);
    }
};
    template<typename S>
    struct StreamReader<::VptDetect::VptDetectResult, S> {
        static void read(S *istr, ::VptDetect::VptDetectResult &v) {
            istr->read(v.sdkDetectType);
            istr->read(v.bskRect);
            istr->read(v.personDetectRes);
            istr->read(v.perRideCarDetectRes);
            istr->read(v.carDetectRes);
        }
    };

}

namespace VptDetect
{
namespace VptDetect {

template<class T>
class CallbackNC_VptDetectServer_VptDetect : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:
    template<class T>
    class CallbackNC_VptDetectServer_VptDetect
        : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

    typedef IceUtil::Handle<T> TPtr;
        typedef IceUtil::Handle<T> TPtr;

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::ObjInfos&);
        typedef void (T::*Exception)(const ::Ice::Exception &);

    CallbackNC_VptDetectServer_VptDetect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
        typedef void (T::*Sent)(bool);

        typedef void (T::*Response)(const ::VptDetect::ObjInfos &);

        CallbackNC_VptDetectServer_VptDetect(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::ObjInfos ret;
            try {
                ret = proxy->end_VptDetect(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T> &instance,
                                          void (T::*cb)(const ::VptDetect::ObjInfos &),
                                          void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::ObjInfos ret;
        try
        {
            ret = proxy->end_VptDetect(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    template<class T>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(T *instance, void (T::*cb)(const ::VptDetect::ObjInfos &),
                                          void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
    }

private:
    template<class T, typename CT>
    class Callback_VptDetectServer_VptDetect
        : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::ObjInfos&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

template<class T> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(T* instance, void (T::*cb)(const ::VptDetect::ObjInfos&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_VptDetect<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool, const CT &);

template<class T, typename CT>
class Callback_VptDetectServer_VptDetect : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:
        typedef void (T::*Response)(const ::VptDetect::ObjInfos &, const CT &);

    typedef IceUtil::Handle<T> TPtr;
        Callback_VptDetectServer_VptDetect(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::ObjInfos&, const CT&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::ObjInfos ret;
            try {
                ret = proxy->end_VptDetect(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        }

    Callback_VptDetectServer_VptDetect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T> &instance,
                                          void (T::*cb)(const ::VptDetect::ObjInfos &, const CT &),
                                          void (T::*excb)(const ::Ice::Exception &, const CT &),
                                          void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::ObjInfos ret;
        try
        {
            ret = proxy->end_VptDetect(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    template<class T, typename CT>
    Callback_VptDetectServer_VptDetectPtr
    newCallback_VptDetectServer_VptDetect(T *instance, void (T::*cb)(const ::VptDetect::ObjInfos &, const CT &),
                                          void (T::*excb)(const ::Ice::Exception &, const CT &),
                                          void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
    }

private:
    template<class T>
    class CallbackNC_VptDetectServer_getStr
        : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T, typename CT> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::ObjInfos&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &);

template<class T, typename CT> Callback_VptDetectServer_VptDetectPtr
newCallback_VptDetectServer_VptDetect(T* instance, void (T::*cb)(const ::VptDetect::ObjInfos&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_VptDetect<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool);

template<class T>
class CallbackNC_VptDetectServer_getStr : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringDatas &);

    typedef IceUtil::Handle<T> TPtr;
        CallbackNC_VptDetectServer_getStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    CallbackNC_VptDetectServer_getStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(const IceUtil::Handle<T> &instance,
                                       void (T::*cb)(const ::VptDetect::stringDatas &),
                                       void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    template<class T>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &),
                                       void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
    }

private:
    template<class T, typename CT>
    class Callback_VptDetectServer_getStr
        : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

template<class T> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool, const CT &);

template<class T, typename CT>
class Callback_VptDetectServer_getStr : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringDatas &, const CT &);

    typedef IceUtil::Handle<T> TPtr;
        Callback_VptDetectServer_getStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&, const CT&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        }

    Callback_VptDetectServer_getStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(const IceUtil::Handle<T> &instance,
                                       void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                       void (T::*excb)(const ::Ice::Exception &, const CT &),
                                       void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    template<class T, typename CT>
    Callback_VptDetectServer_getStrPtr
    newCallback_VptDetectServer_getStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                       void (T::*excb)(const ::Ice::Exception &, const CT &),
                                       void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
    }

private:
    template<class T>
    class CallbackNC_VptDetectServer_getTypeStr
        : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T, typename CT> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &);

template<class T, typename CT> Callback_VptDetectServer_getStrPtr
newCallback_VptDetectServer_getStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getStr<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool);

template<class T>
class CallbackNC_VptDetectServer_getTypeStr : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringData &);

    typedef IceUtil::Handle<T> TPtr;
        CallbackNC_VptDetectServer_getTypeStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringData&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getTypeStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    CallbackNC_VptDetectServer_getTypeStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T> &instance,
                                           void (T::*cb)(const ::VptDetect::stringData &),
                                           void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getTypeStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    template<class T>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(T *instance, void (T::*cb)(const ::VptDetect::stringData &),
                                           void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
    }

private:
    template<class T, typename CT>
    class Callback_VptDetectServer_getTypeStr
        : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

template<class T> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(T* instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getTypeStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool, const CT &);

template<class T, typename CT>
class Callback_VptDetectServer_getTypeStr : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringData &, const CT &);

    typedef IceUtil::Handle<T> TPtr;
        Callback_VptDetectServer_getTypeStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringData&, const CT&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getTypeStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        }

    Callback_VptDetectServer_getTypeStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T> &instance,
                                           void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                           void (T::*excb)(const ::Ice::Exception &, const CT &),
                                           void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getTypeStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    template<class T, typename CT>
    Callback_VptDetectServer_getTypeStrPtr
    newCallback_VptDetectServer_getTypeStr(T *instance, void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                           void (T::*excb)(const ::Ice::Exception &, const CT &),
                                           void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
    }

private:
    template<class T>
    class CallbackNC_VptDetectServer_getColorLabel
        : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T, typename CT> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &);

template<class T, typename CT> Callback_VptDetectServer_getTypeStrPtr
newCallback_VptDetectServer_getTypeStr(T* instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getTypeStr<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool);

template<class T>
class CallbackNC_VptDetectServer_getColorLabel : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringData &);

    typedef IceUtil::Handle<T> TPtr;
        CallbackNC_VptDetectServer_getColorLabel(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringData&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getColorLabel(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    CallbackNC_VptDetectServer_getColorLabel(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T> &instance,
                                              void (T::*cb)(const ::VptDetect::stringData &),
                                              void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getColorLabel(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    template<class T>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(T *instance, void (T::*cb)(const ::VptDetect::stringData &),
                                              void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
    }

private:
    template<class T, typename CT>
    class Callback_VptDetectServer_getColorLabel
        : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

template<class T> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(T* instance, void (T::*cb)(const ::VptDetect::stringData&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getColorLabel<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool, const CT &);

template<class T, typename CT>
class Callback_VptDetectServer_getColorLabel : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringData &, const CT &);

    typedef IceUtil::Handle<T> TPtr;
        Callback_VptDetectServer_getColorLabel(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringData&, const CT&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringData ret;
            try {
                ret = proxy->end_getColorLabel(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        }

    Callback_VptDetectServer_getColorLabel(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T> &instance,
                                              void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                              void (T::*excb)(const ::Ice::Exception &, const CT &),
                                              void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringData ret;
        try
        {
            ret = proxy->end_getColorLabel(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    template<class T, typename CT>
    Callback_VptDetectServer_getColorLabelPtr
    newCallback_VptDetectServer_getColorLabel(T *instance, void (T::*cb)(const ::VptDetect::stringData &, const CT &),
                                              void (T::*excb)(const ::Ice::Exception &, const CT &),
                                              void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
    }

private:
    template<class T>
    class CallbackNC_VptDetectServer_getHpResStr
        : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T, typename CT> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &);

template<class T, typename CT> Callback_VptDetectServer_getColorLabelPtr
newCallback_VptDetectServer_getColorLabel(T* instance, void (T::*cb)(const ::VptDetect::stringData&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getColorLabel<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool);

template<class T>
class CallbackNC_VptDetectServer_getHpResStr : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringDatas &);

    typedef IceUtil::Handle<T> TPtr;
        CallbackNC_VptDetectServer_getHpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    CallbackNC_VptDetectServer_getHpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T> &instance,
                                            void (T::*cb)(const ::VptDetect::stringDatas &),
                                            void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    template<class T>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &),
                                            void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
    }

private:
    template<class T, typename CT>
    class Callback_VptDetectServer_getHpResStr
        : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

template<class T> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHpResStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool, const CT &);

template<class T, typename CT>
class Callback_VptDetectServer_getHpResStr : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringDatas &, const CT &);

    typedef IceUtil::Handle<T> TPtr;
        Callback_VptDetectServer_getHpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&, const CT&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        }

    Callback_VptDetectServer_getHpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T> &instance,
                                            void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                            void (T::*excb)(const ::Ice::Exception &, const CT &),
                                            void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    template<class T, typename CT>
    Callback_VptDetectServer_getHpResStrPtr
    newCallback_VptDetectServer_getHpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                            void (T::*excb)(const ::Ice::Exception &, const CT &),
                                            void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
    }

private:
    template<class T>
    class CallbackNC_VptDetectServer_getHcpResStr
        : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T, typename CT> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &);

template<class T, typename CT> Callback_VptDetectServer_getHpResStrPtr
newCallback_VptDetectServer_getHpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHpResStr<T, CT>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool);

template<class T>
class CallbackNC_VptDetectServer_getHcpResStr : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallbackNC<T>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringDatas &);

    typedef IceUtil::Handle<T> TPtr;
        CallbackNC_VptDetectServer_getHcpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHcpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
            }
        }

    CallbackNC_VptDetectServer_getHcpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T> &instance,
                                             void (T::*cb)(const ::VptDetect::stringDatas &),
                                             void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHcpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::CallbackNC<T>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
        }
    template<class T>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &),
                                             void (T::*excb)(const ::Ice::Exception &), void (T::*sentcb)(bool) = 0) {
        return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
    }

private:
    template<class T, typename CT>
    class Callback_VptDetectServer_getHcpResStr
        : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
    public:

    Response _response;
};
        typedef IceUtil::Handle<T> TPtr;

template<class T> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Exception)(const ::Ice::Exception &, const CT &);

template<class T> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_VptDetectServer_getHcpResStr<T>(instance, cb, excb, sentcb);
}
        typedef void (T::*Sent)(bool, const CT &);

template<class T, typename CT>
class Callback_VptDetectServer_getHcpResStr : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallback<T, CT>
{
public:
        typedef void (T::*Response)(const ::VptDetect::stringDatas &, const CT &);

    typedef IceUtil::Handle<T> TPtr;
        Callback_VptDetectServer_getHcpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
        }

    typedef void (T::*Exception)(const ::Ice::Exception& , const CT&);
    typedef void (T::*Sent)(bool , const CT&);
    typedef void (T::*Response)(const ::VptDetect::stringDatas&, const CT&);
        virtual void completed(const ::Ice::AsyncResultPtr &result) const {
            ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
            ::VptDetect::stringDatas ret;
            try {
                ret = proxy->end_getHcpResStr(result);
            }
            catch (const ::Ice::Exception &ex) {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response) {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret,
                                                                              CT::dynamicCast(result->getCookie()));
            }
        }

    Callback_VptDetectServer_getHcpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
    {
    private:

        Response _response;
    };

    template<class T, typename CT>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T> &instance,
                                             void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                             void (T::*excb)(const ::Ice::Exception &, const CT &),
                                             void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
    }

    virtual void completed(const ::Ice::AsyncResultPtr& result) const
    {
        ::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
        ::VptDetect::stringDatas ret;
        try
        {
            ret = proxy->end_getHcpResStr(result);
        }
        catch(const ::Ice::Exception& ex)
        {
            ::IceInternal::Callback<T, CT>::exception(result, ex);
            return;
        }
        if(_response)
        {
            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
        }
    template<class T, typename CT>
    Callback_VptDetectServer_getHcpResStrPtr
    newCallback_VptDetectServer_getHcpResStr(T *instance, void (T::*cb)(const ::VptDetect::stringDatas &, const CT &),
                                             void (T::*excb)(const ::Ice::Exception &, const CT &),
                                             void (T::*sentcb)(bool, const CT &) = 0) {
        return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
    }

private:

    Response _response;
};

template<class T, typename CT> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_VptDetectServer_getHcpResStrPtr
newCallback_VptDetectServer_getHcpResStr(T* instance, void (T::*cb)(const ::VptDetect::stringDatas&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_VptDetectServer_getHcpResStr<T, CT>(instance, cb, excb, sentcb);
}

}

#endif

#include <IceUtil/PopDisableWarnings.h>

#endif