~chenshijun/c++.git

			@@ -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,59 +476,63 @@

			#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 );

			}

			}

			namespace VptDetect {
			namespace VptDetect
			{

			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 {
			struct RECT
			{
			::Ice::Float left;
			::Ice::Float top;
			::Ice::Float width;
			::Ice::Float height;
			};

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

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

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

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

			struct CarDetectRes {
			struct CarDetectRes
			{
			::std::string vehicle_brand;
			::std::string vehicle_subbrand;
			::std::string vehicle_issue_year;
			@@ -543,8 +548,10 @@
			::Ice::Int carPlatetype;
			};

			struct VptDetectResult {
			struct VptDetectResult
			{
			::Ice::Int sdkDetectType;
			::Ice::Float obj_score;
			::VptDetect::RECT bskRect;
			::VptDetect::PersonDetectRes personDetectRes;
			::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
			@@ -559,88 +566,66 @@

			}

			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;

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

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

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

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

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

			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 {
			};

			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 {
			};

			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> {
			class VptDetectServer : public virtual ::Ice::Proxy<VptDetectServer, ::IceProxy::Ice::Object>
			{
			public:

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

			::Ice::AsyncResultPtr
			begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string &iceP_shareMemory,
			const ::Ice::Context &context = ::Ice::noExplicitContext) {
			return _iceI_begin_VptDetect(iceP_width, iceP_height, iceP_shareMemory, context,
			::IceInternal::dummyCallback, 0);
			::Ice::AsyncResultPtr begin_VptDetect(::Ice::Int iceP_width, ::Ice::Int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::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::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) {
			::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 ::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) {
			::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);
			}

			@@ -648,43 +633,37 @@

			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);
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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);
			}

			@@ -692,38 +671,37 @@

			private:

			::Ice::AsyncResultPtr
			_iceI_begin_getStr(::Ice::Int, const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
			const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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);
			}

			@@ -731,37 +709,37 @@

			private:

			::Ice::AsyncResultPtr _iceI_begin_getTypeStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
			const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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);
			}

			@@ -769,38 +747,37 @@

			private:

			::Ice::AsyncResultPtr
			_iceI_begin_getColorLabel(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
			const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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);
			}

			@@ -808,38 +785,37 @@

			private:

			::Ice::AsyncResultPtr
			_iceI_begin_getHpResStr(const ::Ice::Context &, const ::IceInternal::CallbackBasePtr &,
			const ::Ice::LocalObjectPtr &cookie = 0, bool sync = false);
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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) {
			::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);
			}

			@@ -847,9 +823,7 @@

			private:

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

			public:

			@@ -864,9 +838,11 @@

			}

			namespace VptDetect {
			namespace VptDetect
			{

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

			typedef VptDetectServerPrx ProxyType;
			@@ -875,36 +851,27 @@
			virtual ~VptDetectServer();

			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;

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

			virtual ::VptDetect::ObjInfos
			VptDetect(::Ice::Int, ::Ice::Int, const ::std::string &, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

			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::stringDatas getStr(::Ice::Int, const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

			bool _iceD_getStr(::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::stringData getColorLabel(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

			bool _iceD_getColorLabel(::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::stringDatas getHcpResStr(const ::Ice::Current & = ::Ice::emptyCurrent) = 0;

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

			virtual bool _iceDispatch(::IceInternal::Incoming &, const ::Ice::Current &);
			@@ -912,32 +879,37 @@
			protected:

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

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

			inline bool operator==(const VptDetectServer &lhs, const VptDetectServer &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) {
			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> {
			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) {
			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);
			@@ -946,8 +918,10 @@
			};

			template<typename S>
			struct StreamReader<::VptDetect::RECT, S> {
			static void read(S *istr, ::VptDetect::RECT &v) {
			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);
			@@ -956,80 +930,98 @@
			};

			template<>
			struct StreamableTraits<::VptDetect::ClassfyObjRes> {
			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) {
			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) {
			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> {
			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) {
			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) {
			struct StreamReader< ::VptDetect::PersonDetectRes, S>
			{
			static void read(S* istr, ::VptDetect::PersonDetectRes& v)
			{
			istr->read(v.res_objs);
			}
			};

			template<>
			struct StreamableTraits<::VptDetect::PerRideCarDetectRes> {
			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) {
			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) {
			struct StreamReader< ::VptDetect::PerRideCarDetectRes, S>
			{
			static void read(S* istr, ::VptDetect::PerRideCarDetectRes& v)
			{
			istr->read(v.res_objs);
			}
			};

			template<>
			struct StreamableTraits<::VptDetect::CarDetectRes> {
			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) {
			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);
			@@ -1047,8 +1039,10 @@
			};

			template<typename S>
			struct StreamReader<::VptDetect::CarDetectRes, S> {
			static void read(S *istr, ::VptDetect::CarDetectRes &v) {
			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);
			@@ -1066,16 +1060,20 @@
			};

			template<>
			struct StreamableTraits<::VptDetect::VptDetectResult> {
			struct StreamableTraits< ::VptDetect::VptDetectResult>
			{
			static const StreamHelperCategory helper = StreamHelperCategoryStruct;
			static const int minWireSize = 68;
			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) {
			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);
			@@ -1084,9 +1082,12 @@
			};

			template<typename S>
			struct StreamReader<::VptDetect::VptDetectResult, S> {
			static void read(S *istr, ::VptDetect::VptDetectResult &v) {
			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);
			@@ -1096,36 +1097,40 @@

			}

			namespace VptDetect {
			namespace VptDetect
			{

			template<class T>
			class CallbackNC_VptDetectServer_VptDetect
			: public Callback_VptDetectServer_VptDetect_Base, public ::IceInternal::TwowayCallbackNC<T> {
			class CallbackNC_VptDetectServer_VptDetect : public Callback_VptDetectServer_VptDetect_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::ObjInfos &);

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

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::ObjInfos ret;
			try {
			try
			{
			ret = proxy->end_VptDetect(result);
			}
			catch (const ::Ice::Exception &ex) {
			catch(const ::Ice::Exception& ex)
			{
			::IceInternal::CallbackNC<T>::exception(result, ex);
			return;
			}
			if (_response) {
			if(_response)
			{
			(::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
			}
			}
			@@ -1135,51 +1140,50 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::ObjInfos ret;
			try {
			try
			{
			ret = proxy->end_VptDetect(result);
			}
			catch (const ::Ice::Exception &ex) {
			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()));
			}
			}

			@@ -1188,51 +1192,49 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringDatas ret;
			try {
			try
			{
			ret = proxy->end_getStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			catch(const ::Ice::Exception& ex)
			{
			::IceInternal::CallbackNC<T>::exception(result, ex);
			return;
			}
			if (_response) {
			if(_response)
			{
			(::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
			}
			}
			@@ -1242,51 +1244,50 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringDatas ret;
			try {
			try
			{
			ret = proxy->end_getStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			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()));
			}
			}

			@@ -1295,51 +1296,49 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringData ret;
			try {
			try
			{
			ret = proxy->end_getTypeStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			catch(const ::Ice::Exception& ex)
			{
			::IceInternal::CallbackNC<T>::exception(result, ex);
			return;
			}
			if (_response) {
			if(_response)
			{
			(::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
			}
			}
			@@ -1349,51 +1348,50 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringData ret;
			try {
			try
			{
			ret = proxy->end_getTypeStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			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()));
			}
			}

			@@ -1402,51 +1400,49 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringData ret;
			try {
			try
			{
			ret = proxy->end_getColorLabel(result);
			}
			catch (const ::Ice::Exception &ex) {
			catch(const ::Ice::Exception& ex)
			{
			::IceInternal::CallbackNC<T>::exception(result, ex);
			return;
			}
			if (_response) {
			if(_response)
			{
			(::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
			}
			}
			@@ -1456,51 +1452,50 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringData ret;
			try {
			try
			{
			ret = proxy->end_getColorLabel(result);
			}
			catch (const ::Ice::Exception &ex) {
			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()));
			}
			}

			@@ -1509,51 +1504,49 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringDatas ret;
			try {
			try
			{
			ret = proxy->end_getHpResStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			catch(const ::Ice::Exception& ex)
			{
			::IceInternal::CallbackNC<T>::exception(result, ex);
			return;
			}
			if (_response) {
			if(_response)
			{
			(::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
			}
			}
			@@ -1563,51 +1556,50 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringDatas ret;
			try {
			try
			{
			ret = proxy->end_getHpResStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			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()));
			}
			}

			@@ -1616,51 +1608,49 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallbackNC<T>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringDatas ret;
			try {
			try
			{
			ret = proxy->end_getHcpResStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			catch(const ::Ice::Exception& ex)
			{
			::IceInternal::CallbackNC<T>::exception(result, ex);
			return;
			}
			if (_response) {
			if(_response)
			{
			(::IceInternal::CallbackNC<T>::_callback.get()->*_response)(ret);
			}
			}
			@@ -1670,51 +1660,50 @@
			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) {
			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) {
			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> {
			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) {
			: ::IceInternal::TwowayCallback<T, CT>(obj, cb != 0, excb, sentcb), _response(cb)
			{
			}

			virtual void completed(const ::Ice::AsyncResultPtr &result) const {
			virtual void completed(const ::Ice::AsyncResultPtr& result) const
			{
			::VptDetect::VptDetectServerPrx proxy = ::VptDetect::VptDetectServerPrx::uncheckedCast(result->getProxy());
			::VptDetect::stringDatas ret;
			try {
			try
			{
			ret = proxy->end_getHcpResStr(result);
			}
			catch (const ::Ice::Exception &ex) {
			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()));
			}
			}

			@@ -1723,20 +1712,15 @@
			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) {
			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) {
			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);
			}

			@@ -1745,5 +1729,4 @@
			#endif

			#include <IceUtil/PopDisableWarnings.h>

			#endif