From 779b80d18f41fb855bc91eb6e5470d26665e6683 Mon Sep 17 00:00:00 2001
From: pansen <pansen626@sina.com>
Date: 星期四, 11 四月 2019 15:36:32 +0800
Subject: [PATCH] 添加VptElement

---
 QiaoJiaSystem/VptServer/rpc/VptServer.h | 2267 +++++++++++++++++++++++++++++------------------------------
 1 files changed, 1,125 insertions(+), 1,142 deletions(-)

diff --git a/QiaoJiaSystem/VptServer/rpc/VptServer.h b/QiaoJiaSystem/VptServer/rpc/VptServer.h
index dda6031..aaaa9eb 100644
--- a/QiaoJiaSystem/VptServer/rpc/VptServer.h
+++ b/QiaoJiaSystem/VptServer/rpc/VptServer.h
@@ -135,14 +135,15 @@
 struct VptDetectResult
 {
     int sdkDetectType;
+    float obj_score;
     ::VptDetect::RECT bskRect;
     ::VptDetect::PersonDetectRes personDetectRes;
     ::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
     ::VptDetect::CarDetectRes carDetectRes;
 
-    std::tuple<const int&, const ::VptDetect::RECT&, const ::VptDetect::PersonDetectRes&, const ::VptDetect::PerRideCarDetectRes&, const ::VptDetect::CarDetectRes&> ice_tuple() const
+    std::tuple<const int&, const float&, const ::VptDetect::RECT&, const ::VptDetect::PersonDetectRes&, const ::VptDetect::PerRideCarDetectRes&, const ::VptDetect::CarDetectRes&> ice_tuple() const
     {
-        return std::tie(sdkDetectType, bskRect, personDetectRes, perRideCarDetectRes, carDetectRes);
+        return std::tie(sdkDetectType, obj_score, bskRect, personDetectRes, perRideCarDetectRes, carDetectRes);
     }
 };
 
@@ -450,7 +451,7 @@
 struct StreamableTraits<::VptDetect::VptDetectResult>
 {
     static const StreamHelperCategory helper = StreamHelperCategoryStruct;
-    static const int minWireSize = 68;
+    static const int minWireSize = 72;
     static const bool fixedLength = false;
 };
 
@@ -459,7 +460,7 @@
 {
     static void read(S* istr, ::VptDetect::VptDetectResult& v)
     {
-        istr->readAll(v.sdkDetectType, v.bskRect, v.personDetectRes, v.perRideCarDetectRes, v.carDetectRes);
+        istr->readAll(v.sdkDetectType, v.obj_score, v.bskRect, v.personDetectRes, v.perRideCarDetectRes, v.carDetectRes);
     }
 };
 
@@ -475,1275 +476,1257 @@
 
 #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 {
+}
 
-    class VptDetectServer;
+namespace VptDetect
+{
 
-    ::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 &);
+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&);
 
 }
 
-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;
+    ::Ice::Float obj_score;
+    ::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 {
-    };
+class Callback_VptDetectServer_VptDetect_Base : public virtual ::IceInternal::CallbackBase { };
+typedef ::IceUtil::Handle< Callback_VptDetectServer_VptDetect_Base> Callback_VptDetectServer_VptDetectPtr;
 
-    typedef ::IceUtil::Handle<Callback_VptDetectServer_VptDetect_Base> Callback_VptDetectServer_VptDetectPtr;
+class Callback_VptDetectServer_getStr_Base : public virtual ::IceInternal::CallbackBase { };
+typedef ::IceUtil::Handle< Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;
 
-    class Callback_VptDetectServer_getStr_Base : public virtual ::IceInternal::CallbackBase {
-    };
+class Callback_VptDetectServer_getTypeStr_Base : public virtual ::IceInternal::CallbackBase { };
+typedef ::IceUtil::Handle< Callback_VptDetectServer_getTypeStr_Base> Callback_VptDetectServer_getTypeStrPtr;
 
-    typedef ::IceUtil::Handle<Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;
+class Callback_VptDetectServer_getColorLabel_Base : public virtual ::IceInternal::CallbackBase { };
+typedef ::IceUtil::Handle< Callback_VptDetectServer_getColorLabel_Base> Callback_VptDetectServer_getColorLabelPtr;
 
-    class Callback_VptDetectServer_getTypeStr_Base : public virtual ::IceInternal::CallbackBase {
-    };
+class Callback_VptDetectServer_getHpResStr_Base : public virtual ::IceInternal::CallbackBase { };
+typedef ::IceUtil::Handle< Callback_VptDetectServer_getHpResStr_Base> Callback_VptDetectServer_getHpResStrPtr;
 
-    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;
+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));
-            }
-
-            ::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;
-        };
-
+    ::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;
+};
 
 }
 
-namespace VptDetect {
+}
 
-    class VptDetectServer : public virtual ::Ice::Object {
-    public:
+namespace VptDetect
+{
 
-        typedef VptDetectServerPrx ProxyType;
-        typedef VptDetectServerPtr PointerType;
+class VptDetectServer : public virtual ::Ice::Object
+{
+public:
 
-        virtual ~VptDetectServer();
+    typedef VptDetectServerPrx ProxyType;
+    typedef VptDetectServerPtr PointerType;
 
-        virtual bool ice_isA(const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) const;
+    virtual ~VptDetectServer();
 
-        virtual ::std::vector<::std::string> ice_ids(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 const ::std::string &ice_id(const ::Ice::Current & = ::Ice::emptyCurrent) const;
+    static const ::std::string& ice_staticId();
 
-        static const ::std::string &ice_staticId();
+    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&);
 
-        virtual ::VptDetect::ObjInfos
-        VptDetect(::Ice::Int, ::Ice::Int, const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
+    virtual ::VptDetect::stringDatas getStr(::Ice::Int, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    bool _iceD_getStr(::IceInternal::Incoming&, const ::Ice::Current&);
 
-        bool _iceD_VptDetect(::IceInternal::Incoming &, const ::Ice::Current &);
+    virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    bool _iceD_getTypeStr(::IceInternal::Incoming&, const ::Ice::Current&);
 
-        virtual ::VptDetect::stringDatas getStr(::Ice::Int, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
+    virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    bool _iceD_getColorLabel(::IceInternal::Incoming&, const ::Ice::Current&);
 
-        bool _iceD_getStr(::IceInternal::Incoming &, const ::Ice::Current &);
+    virtual ::VptDetect::stringDatas getHpResStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    bool _iceD_getHpResStr(::IceInternal::Incoming&, const ::Ice::Current&);
 
-        virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
+    virtual ::VptDetect::stringDatas getHcpResStr(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
+    bool _iceD_getHcpResStr(::IceInternal::Incoming&, const ::Ice::Current&);
 
-        bool _iceD_getTypeStr(::IceInternal::Incoming &, const ::Ice::Current &);
+    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
 
-        virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;
+protected:
 
-        bool _iceD_getColorLabel(::IceInternal::Incoming &, const ::Ice::Current &);
+    virtual void _iceWriteImpl(::Ice::OutputStream*) const;
+    virtual void _iceReadImpl(::Ice::InputStream*);
+};
 
-        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);
-    }
+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 = 72;
+    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.obj_score);
+        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.obj_score);
+        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::*Exception)(const ::Ice::Exception&);
+    typedef void (T::*Sent)(bool);
+    typedef void (T::*Response)(const ::VptDetect::ObjInfos&);
 
-        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);
+    CallbackNC_VptDetectServer_VptDetect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
     }
 
-    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);
-    }
-
-    template<class T, typename CT>
-    class Callback_VptDetectServer_VptDetect
-        : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallback<T, CT> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        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 &);
-
-        Callback_VptDetectServer_VptDetect(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallback<T, CT>(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);
         }
-
-        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()));
-            }
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::CallbackNC<T>::exception(result, ex);
+            return;
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T>
-    class CallbackNC_VptDetectServer_getStr
-        : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        typedef void (T::*Exception)(const ::Ice::Exception &);
-
-        typedef void (T::*Sent)(bool);
-
-        typedef void (T::*Response)(const ::VptDetect::stringDatas &);
-
-        CallbackNC_VptDetectServer_getStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
+        if(_response)
+        {
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
+    }
 
-        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);
-            }
+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);
+}
+
+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);
+}
+
+template<class T, typename CT>
+class Callback_VptDetectServer_VptDetect : public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallback<T, CT>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    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&);
+
+    Callback_VptDetectServer_VptDetect(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallback<T, CT>(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);
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T, typename CT>
-    class Callback_VptDetectServer_getStr
-        : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        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 &);
-
-        Callback_VptDetectServer_getStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::Callback<T, CT>::exception(result, ex);
+            return;
         }
-
-        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()));
-            }
+        if(_response)
+        {
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
         }
-
-    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);
     }
 
-    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:
+
+    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);
+}
+
+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);
+}
+
+template<class T>
+class CallbackNC_VptDetectServer_getStr : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallbackNC<T>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    typedef void (T::*Exception)(const ::Ice::Exception&);
+    typedef void (T::*Sent)(bool);
+    typedef void (T::*Response)(const ::VptDetect::stringDatas&);
+
+    CallbackNC_VptDetectServer_getStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
     }
 
-    template<class T>
-    class CallbackNC_VptDetectServer_getTypeStr
-        : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        typedef void (T::*Exception)(const ::Ice::Exception &);
-
-        typedef void (T::*Sent)(bool);
-
-        typedef void (T::*Response)(const ::VptDetect::stringData &);
-
-        CallbackNC_VptDetectServer_getTypeStr(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::stringDatas ret;
+        try
+        {
+            ret = proxy->end_getStr(result);
         }
-
-        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);
-            }
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::CallbackNC<T>::exception(result, ex);
+            return;
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T, typename CT>
-    class Callback_VptDetectServer_getTypeStr
-        : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        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 &);
-
-        Callback_VptDetectServer_getTypeStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
+        if(_response)
+        {
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
+    }
 
-        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()));
-            }
+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);
+}
+
+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);
+}
+
+template<class T, typename CT>
+class Callback_VptDetectServer_getStr : public Callback_VptDetectServer_getStr_Base, public ::IceInternal::TwowayCallback<T, CT>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    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&);
+
+    Callback_VptDetectServer_getStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
+    }
+
+    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);
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T>
-    class CallbackNC_VptDetectServer_getColorLabel
-        : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallbackNC<T> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        typedef void (T::*Exception)(const ::Ice::Exception &);
-
-        typedef void (T::*Sent)(bool);
-
-        typedef void (T::*Response)(const ::VptDetect::stringData &);
-
-        CallbackNC_VptDetectServer_getColorLabel(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::Callback<T, CT>::exception(result, ex);
+            return;
         }
-
-        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);
-            }
+        if(_response)
+        {
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
         }
-
-    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);
     }
 
-    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:
+
+    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);
+}
+
+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);
+}
+
+template<class T>
+class CallbackNC_VptDetectServer_getTypeStr : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallbackNC<T>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    typedef void (T::*Exception)(const ::Ice::Exception&);
+    typedef void (T::*Sent)(bool);
+    typedef void (T::*Response)(const ::VptDetect::stringData&);
+
+    CallbackNC_VptDetectServer_getTypeStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
     }
 
-    template<class T, typename CT>
-    class Callback_VptDetectServer_getColorLabel
-        : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallback<T, CT> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        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 &);
-
-        Callback_VptDetectServer_getColorLabel(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
+    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);
         }
-
-        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()));
-            }
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::CallbackNC<T>::exception(result, ex);
+            return;
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T>
-    class CallbackNC_VptDetectServer_getHpResStr
-        : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        typedef void (T::*Exception)(const ::Ice::Exception &);
-
-        typedef void (T::*Sent)(bool);
-
-        typedef void (T::*Response)(const ::VptDetect::stringDatas &);
-
-        CallbackNC_VptDetectServer_getHpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb) {
+        if(_response)
+        {
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
+    }
 
-        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);
-            }
+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);
+}
+
+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);
+}
+
+template<class T, typename CT>
+class Callback_VptDetectServer_getTypeStr : public Callback_VptDetectServer_getTypeStr_Base, public ::IceInternal::TwowayCallback<T, CT>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    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&);
+
+    Callback_VptDetectServer_getTypeStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
+    }
+
+    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);
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T, typename CT>
-    class Callback_VptDetectServer_getHpResStr
-        : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        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 &);
-
-        Callback_VptDetectServer_getHpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::Callback<T, CT>::exception(result, ex);
+            return;
         }
-
-        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()));
-            }
+        if(_response)
+        {
+            (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(ret, CT::dynamicCast(result->getCookie()));
         }
-
-    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);
     }
 
-    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:
+
+    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);
+}
+
+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);
+}
+
+template<class T>
+class CallbackNC_VptDetectServer_getColorLabel : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallbackNC<T>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    typedef void (T::*Exception)(const ::Ice::Exception&);
+    typedef void (T::*Sent)(bool);
+    typedef void (T::*Response)(const ::VptDetect::stringData&);
+
+    CallbackNC_VptDetectServer_getColorLabel(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
     }
 
-    template<class T>
-    class CallbackNC_VptDetectServer_getHcpResStr
-        : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallbackNC<T> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        typedef void (T::*Exception)(const ::Ice::Exception &);
-
-        typedef void (T::*Sent)(bool);
-
-        typedef void (T::*Response)(const ::VptDetect::stringDatas &);
-
-        CallbackNC_VptDetectServer_getHcpResStr(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::stringData ret;
+        try
+        {
+            ret = proxy->end_getColorLabel(result);
         }
-
-        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);
-            }
+        catch(const ::Ice::Exception& ex)
+        {
+            ::IceInternal::CallbackNC<T>::exception(result, ex);
+            return;
         }
-
-    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);
-    }
-
-    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);
-    }
-
-    template<class T, typename CT>
-    class Callback_VptDetectServer_getHcpResStr
-        : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallback<T, CT> {
-    public:
-
-        typedef IceUtil::Handle<T> TPtr;
-
-        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 &);
-
-        Callback_VptDetectServer_getHcpResStr(const TPtr &obj, Response cb, Exception excb, Sent sentcb)
-            : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb) {
+        if(_response)
+        {
+            (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
         }
+    }
 
-        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()));
-            }
+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);
+}
+
+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);
+}
+
+template<class T, typename CT>
+class Callback_VptDetectServer_getColorLabel : public Callback_VptDetectServer_getColorLabel_Base, public ::IceInternal::TwowayCallback<T, CT>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    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&);
+
+    Callback_VptDetectServer_getColorLabel(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
+    }
+
+    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);
         }
-
-    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);
+        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_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);
+}
+
+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);
+}
+
+template<class T>
+class CallbackNC_VptDetectServer_getHpResStr : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallbackNC<T>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    typedef void (T::*Exception)(const ::Ice::Exception&);
+    typedef void (T::*Sent)(bool);
+    typedef void (T::*Response)(const ::VptDetect::stringDatas&);
+
+    CallbackNC_VptDetectServer_getHpResStr(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::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);
+        }
+    }
+
+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);
+}
+
+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);
+}
+
+template<class T, typename CT>
+class Callback_VptDetectServer_getHpResStr : public Callback_VptDetectServer_getHpResStr_Base, public ::IceInternal::TwowayCallback<T, CT>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    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&);
+
+    Callback_VptDetectServer_getHpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
+    }
+
+    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()));
+        }
+    }
+
+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);
+}
+
+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);
+}
+
+template<class T>
+class CallbackNC_VptDetectServer_getHcpResStr : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallbackNC<T>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    typedef void (T::*Exception)(const ::Ice::Exception&);
+    typedef void (T::*Sent)(bool);
+    typedef void (T::*Response)(const ::VptDetect::stringDatas&);
+
+    CallbackNC_VptDetectServer_getHcpResStr(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::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);
+        }
+    }
+
+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);
+}
+
+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);
+}
+
+template<class T, typename CT>
+class Callback_VptDetectServer_getHcpResStr : public Callback_VptDetectServer_getHcpResStr_Base, public ::IceInternal::TwowayCallback<T, CT>
+{
+public:
+
+    typedef IceUtil::Handle<T> TPtr;
+
+    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&);
+
+    Callback_VptDetectServer_getHcpResStr(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
+        : ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
+    {
+    }
+
+    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()));
+        }
+    }
+
+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