From ad716fb9f1e8ae5cde818be423ca47225a4ff4ec Mon Sep 17 00:00:00 2001
From: pansen <pansen626@sina.com>
Date: 星期四, 11 四月 2019 11:16:29 +0800
Subject: [PATCH] VptServer多线程支持
---
QiaoJiaSystem/VptServer/CMakeLists.txt | 11
QiaoJiaSystem/VptServer/VptServerI.h | 6
QiaoJiaSystem/VptServer/VptDetectWrapper.cpp | 11
QiaoJiaSystem/VptServer/demo.cpp | 116 +++
QiaoJiaSystem/VptServer/VptServerI.cpp | 14
QiaoJiaSystem/VptServer/main.cpp | 4
QiaoJiaSystem/VptServer/rpc/VptServer.h | 2093 +++++++++++++++++++++++++++---------------------------
7 files changed, 1,215 insertions(+), 1,040 deletions(-)
diff --git a/QiaoJiaSystem/VptServer/CMakeLists.txt b/QiaoJiaSystem/VptServer/CMakeLists.txt
index 20bb5fd..b7ccfac 100644
--- a/QiaoJiaSystem/VptServer/CMakeLists.txt
+++ b/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}
+ )
diff --git a/QiaoJiaSystem/VptServer/VptDetectWrapper.cpp b/QiaoJiaSystem/VptServer/VptDetectWrapper.cpp
index 924e8bd..186e7f5 100644
--- a/QiaoJiaSystem/VptServer/VptDetectWrapper.cpp
+++ b/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);
}
diff --git a/QiaoJiaSystem/VptServer/VptServerI.cpp b/QiaoJiaSystem/VptServer/VptServerI.cpp
index c8b3361..e08fa75 100644
--- a/QiaoJiaSystem/VptServer/VptServerI.cpp
+++ b/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 ¤t) {
+ 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()) {
diff --git a/QiaoJiaSystem/VptServer/VptServerI.h b/QiaoJiaSystem/VptServer/VptServerI.h
index e6e5e9a..04e48bb 100644
--- a/QiaoJiaSystem/VptServer/VptServerI.h
+++ b/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;
};
diff --git a/QiaoJiaSystem/VptServer/demo.cpp b/QiaoJiaSystem/VptServer/demo.cpp
new file mode 100644
index 0000000..c97d4ed
--- /dev/null
+++ b/QiaoJiaSystem/VptServer/demo.cpp
@@ -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;
+}
+
diff --git a/QiaoJiaSystem/VptServer/main.cpp b/QiaoJiaSystem/VptServer/main.cpp
index 16027c8..f60dc52 100644
--- a/QiaoJiaSystem/VptServer/main.cpp
+++ b/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;
}
diff --git a/QiaoJiaSystem/VptServer/rpc/VptServer.h b/QiaoJiaSystem/VptServer/rpc/VptServer.h
index e41584d..dda6031 100644
--- a/QiaoJiaSystem/VptServer/rpc/VptServer.h
+++ b/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
--
Gitblit v1.8.0