// **********************************************************************
|
//
|
// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
|
//
|
// This copy of Ice is licensed to you under the terms described in the
|
// ICE_LICENSE file included in this distribution.
|
//
|
// **********************************************************************
|
//
|
// Ice version 3.7.0
|
//
|
// <auto-generated>
|
//
|
// Generated from file `VptServer.ice'
|
//
|
// Warning: do not edit this file.
|
//
|
// </auto-generated>
|
//
|
|
#ifndef __VptServer_h__
|
#define __VptServer_h__
|
|
#include <IceUtil/PushDisableWarnings.h>
|
#include <Ice/ProxyF.h>
|
#include <Ice/ObjectF.h>
|
#include <Ice/ValueF.h>
|
#include <Ice/Exception.h>
|
#include <Ice/LocalObject.h>
|
#include <Ice/StreamHelpers.h>
|
#include <Ice/Comparable.h>
|
#include <Ice/Proxy.h>
|
#include <Ice/Object.h>
|
#include <Ice/GCObject.h>
|
#include <Ice/Value.h>
|
#include <Ice/Incoming.h>
|
#include <Ice/FactoryTableInit.h>
|
#include <IceUtil/ScopedArray.h>
|
#include <Ice/Optional.h>
|
#include <IceUtil/UndefSysMacros.h>
|
|
#ifndef ICE_IGNORE_VERSION
|
# if ICE_INT_VERSION / 100 != 307
|
# error Ice version mismatch!
|
# endif
|
# if ICE_INT_VERSION % 100 > 50
|
# error Beta header file detected
|
# endif
|
# if ICE_INT_VERSION % 100 < 0
|
# error Ice patch level mismatch!
|
# endif
|
#endif
|
|
#ifdef ICE_CPP11_MAPPING // C++11 mapping
|
|
namespace VptDetect
|
{
|
|
class VptDetectServer;
|
class VptDetectServerPrx;
|
|
}
|
|
namespace VptDetect
|
{
|
|
struct RECT
|
{
|
float left;
|
float top;
|
float width;
|
float height;
|
|
std::tuple<const float&, const float&, const float&, const float&> ice_tuple() const
|
{
|
return std::tie(left, top, width, height);
|
}
|
};
|
|
struct ClassfyObjRes
|
{
|
int res_index;
|
float res_prob;
|
|
std::tuple<const int&, const float&> ice_tuple() const
|
{
|
return std::tie(res_index, res_prob);
|
}
|
};
|
|
using ResObjs = ::std::vector<::VptDetect::ClassfyObjRes>;
|
|
struct PersonDetectRes
|
{
|
::VptDetect::ResObjs res_objs;
|
|
std::tuple<const ::VptDetect::ResObjs&> ice_tuple() const
|
{
|
return std::tie(res_objs);
|
}
|
};
|
|
struct PerRideCarDetectRes
|
{
|
::VptDetect::ResObjs res_objs;
|
|
std::tuple<const ::VptDetect::ResObjs&> ice_tuple() const
|
{
|
return std::tie(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;
|
float vehicle_score;
|
int colorLabel;
|
float colorLabelProb;
|
::VptDetect::RECT carPlateRect;
|
float carPlateRectScore;
|
::std::string carPlate;
|
float carPlateScore;
|
int carPlatetype;
|
|
std::tuple<const ::std::string&, const ::std::string&, const ::std::string&, const ::std::string&, const ::std::string&, const float&, const int&, const float&, const ::VptDetect::RECT&, const float&, const ::std::string&, const float&, const int&> ice_tuple() const
|
{
|
return std::tie(vehicle_brand, vehicle_subbrand, vehicle_issue_year, vehicle_type, freight_ton, vehicle_score, colorLabel, colorLabelProb, carPlateRect, carPlateRectScore, carPlate, carPlateScore, carPlatetype);
|
}
|
};
|
|
struct VptDetectResult
|
{
|
int sdkDetectType;
|
::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
|
{
|
return std::tie(sdkDetectType, bskRect, personDetectRes, perRideCarDetectRes, carDetectRes);
|
}
|
};
|
|
using ObjInfos = ::std::vector<::VptDetect::VptDetectResult>;
|
|
using stringData = ::std::vector<::std::string>;
|
|
using stringDatas = ::std::vector<::VptDetect::stringData>;
|
|
using Ice::operator<;
|
using Ice::operator<=;
|
using Ice::operator>;
|
using Ice::operator>=;
|
using Ice::operator==;
|
using Ice::operator!=;
|
|
}
|
|
namespace VptDetect
|
{
|
|
class VptDetectServer : public virtual ::Ice::Object
|
{
|
public:
|
|
using ProxyType = VptDetectServerPrx;
|
|
virtual bool ice_isA(::std::string, const ::Ice::Current&) const override;
|
virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current&) const override;
|
virtual ::std::string ice_id(const ::Ice::Current&) const override;
|
|
static const ::std::string& ice_staticId();
|
|
virtual ::VptDetect::ObjInfos VptDetect(int, int, ::std::string, const ::Ice::Current&) = 0;
|
bool _iceD_VptDetect(::IceInternal::Incoming&, const ::Ice::Current&);
|
|
virtual ::VptDetect::stringDatas getStr(int, const ::Ice::Current&) = 0;
|
bool _iceD_getStr(::IceInternal::Incoming&, const ::Ice::Current&);
|
|
virtual ::VptDetect::stringData getTypeStr(const ::Ice::Current&) = 0;
|
bool _iceD_getTypeStr(::IceInternal::Incoming&, const ::Ice::Current&);
|
|
virtual ::VptDetect::stringData getColorLabel(const ::Ice::Current&) = 0;
|
bool _iceD_getColorLabel(::IceInternal::Incoming&, const ::Ice::Current&);
|
|
virtual ::VptDetect::stringDatas getHpResStr(const ::Ice::Current&) = 0;
|
bool _iceD_getHpResStr(::IceInternal::Incoming&, const ::Ice::Current&);
|
|
virtual ::VptDetect::stringDatas getHcpResStr(const ::Ice::Current&) = 0;
|
bool _iceD_getHcpResStr(::IceInternal::Incoming&, const ::Ice::Current&);
|
|
virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
|
};
|
|
}
|
|
namespace VptDetect
|
{
|
|
class VptDetectServerPrx : public virtual ::Ice::Proxy<VptDetectServerPrx, ::Ice::ObjectPrx>
|
{
|
public:
|
|
::VptDetect::ObjInfos VptDetect(int iceP_width, int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makePromiseOutgoing<::VptDetect::ObjInfos>(true, this, &VptDetect::VptDetectServerPrx::_iceI_VptDetect, iceP_width, iceP_height, iceP_shareMemory, context).get();
|
}
|
|
template<template<typename> class P = ::std::promise>
|
auto VptDetectAsync(int iceP_width, int iceP_height, const ::std::string& iceP_shareMemory, const ::Ice::Context& context = Ice::noExplicitContext)
|
-> decltype(::std::declval<P<::VptDetect::ObjInfos>>().get_future())
|
{
|
return _makePromiseOutgoing<::VptDetect::ObjInfos, P>(false, this, &VptDetect::VptDetectServerPrx::_iceI_VptDetect, iceP_width, iceP_height, iceP_shareMemory, context);
|
}
|
|
::std::function<void()>
|
VptDetectAsync(int iceP_width, int iceP_height, const ::std::string& iceP_shareMemory,
|
::std::function<void(::VptDetect::ObjInfos)> response,
|
::std::function<void(::std::exception_ptr)> ex = nullptr,
|
::std::function<void(bool)> sent = nullptr,
|
const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makeLamdaOutgoing<::VptDetect::ObjInfos>(response, ex, sent, this, &VptDetect::VptDetectServerPrx::_iceI_VptDetect, iceP_width, iceP_height, iceP_shareMemory, context);
|
}
|
|
void _iceI_VptDetect(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::VptDetect::ObjInfos>>&, int, int, const ::std::string&, const ::Ice::Context&);
|
|
::VptDetect::stringDatas getStr(int iceP_type, const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makePromiseOutgoing<::VptDetect::stringDatas>(true, this, &VptDetect::VptDetectServerPrx::_iceI_getStr, iceP_type, context).get();
|
}
|
|
template<template<typename> class P = ::std::promise>
|
auto getStrAsync(int iceP_type, const ::Ice::Context& context = Ice::noExplicitContext)
|
-> decltype(::std::declval<P<::VptDetect::stringDatas>>().get_future())
|
{
|
return _makePromiseOutgoing<::VptDetect::stringDatas, P>(false, this, &VptDetect::VptDetectServerPrx::_iceI_getStr, iceP_type, context);
|
}
|
|
::std::function<void()>
|
getStrAsync(int iceP_type,
|
::std::function<void(::VptDetect::stringDatas)> response,
|
::std::function<void(::std::exception_ptr)> ex = nullptr,
|
::std::function<void(bool)> sent = nullptr,
|
const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makeLamdaOutgoing<::VptDetect::stringDatas>(response, ex, sent, this, &VptDetect::VptDetectServerPrx::_iceI_getStr, iceP_type, context);
|
}
|
|
void _iceI_getStr(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::VptDetect::stringDatas>>&, int, const ::Ice::Context&);
|
|
::VptDetect::stringData getTypeStr(const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makePromiseOutgoing<::VptDetect::stringData>(true, this, &VptDetect::VptDetectServerPrx::_iceI_getTypeStr, context).get();
|
}
|
|
template<template<typename> class P = ::std::promise>
|
auto getTypeStrAsync(const ::Ice::Context& context = Ice::noExplicitContext)
|
-> decltype(::std::declval<P<::VptDetect::stringData>>().get_future())
|
{
|
return _makePromiseOutgoing<::VptDetect::stringData, P>(false, this, &VptDetect::VptDetectServerPrx::_iceI_getTypeStr, context);
|
}
|
|
::std::function<void()>
|
getTypeStrAsync(::std::function<void(::VptDetect::stringData)> response,
|
::std::function<void(::std::exception_ptr)> ex = nullptr,
|
::std::function<void(bool)> sent = nullptr,
|
const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makeLamdaOutgoing<::VptDetect::stringData>(response, ex, sent, this, &VptDetect::VptDetectServerPrx::_iceI_getTypeStr, context);
|
}
|
|
void _iceI_getTypeStr(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::VptDetect::stringData>>&, const ::Ice::Context&);
|
|
::VptDetect::stringData getColorLabel(const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makePromiseOutgoing<::VptDetect::stringData>(true, this, &VptDetect::VptDetectServerPrx::_iceI_getColorLabel, context).get();
|
}
|
|
template<template<typename> class P = ::std::promise>
|
auto getColorLabelAsync(const ::Ice::Context& context = Ice::noExplicitContext)
|
-> decltype(::std::declval<P<::VptDetect::stringData>>().get_future())
|
{
|
return _makePromiseOutgoing<::VptDetect::stringData, P>(false, this, &VptDetect::VptDetectServerPrx::_iceI_getColorLabel, context);
|
}
|
|
::std::function<void()>
|
getColorLabelAsync(::std::function<void(::VptDetect::stringData)> response,
|
::std::function<void(::std::exception_ptr)> ex = nullptr,
|
::std::function<void(bool)> sent = nullptr,
|
const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makeLamdaOutgoing<::VptDetect::stringData>(response, ex, sent, this, &VptDetect::VptDetectServerPrx::_iceI_getColorLabel, context);
|
}
|
|
void _iceI_getColorLabel(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::VptDetect::stringData>>&, const ::Ice::Context&);
|
|
::VptDetect::stringDatas getHpResStr(const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makePromiseOutgoing<::VptDetect::stringDatas>(true, this, &VptDetect::VptDetectServerPrx::_iceI_getHpResStr, context).get();
|
}
|
|
template<template<typename> class P = ::std::promise>
|
auto getHpResStrAsync(const ::Ice::Context& context = Ice::noExplicitContext)
|
-> decltype(::std::declval<P<::VptDetect::stringDatas>>().get_future())
|
{
|
return _makePromiseOutgoing<::VptDetect::stringDatas, P>(false, this, &VptDetect::VptDetectServerPrx::_iceI_getHpResStr, context);
|
}
|
|
::std::function<void()>
|
getHpResStrAsync(::std::function<void(::VptDetect::stringDatas)> response,
|
::std::function<void(::std::exception_ptr)> ex = nullptr,
|
::std::function<void(bool)> sent = nullptr,
|
const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makeLamdaOutgoing<::VptDetect::stringDatas>(response, ex, sent, this, &VptDetect::VptDetectServerPrx::_iceI_getHpResStr, context);
|
}
|
|
void _iceI_getHpResStr(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::VptDetect::stringDatas>>&, const ::Ice::Context&);
|
|
::VptDetect::stringDatas getHcpResStr(const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makePromiseOutgoing<::VptDetect::stringDatas>(true, this, &VptDetect::VptDetectServerPrx::_iceI_getHcpResStr, context).get();
|
}
|
|
template<template<typename> class P = ::std::promise>
|
auto getHcpResStrAsync(const ::Ice::Context& context = Ice::noExplicitContext)
|
-> decltype(::std::declval<P<::VptDetect::stringDatas>>().get_future())
|
{
|
return _makePromiseOutgoing<::VptDetect::stringDatas, P>(false, this, &VptDetect::VptDetectServerPrx::_iceI_getHcpResStr, context);
|
}
|
|
::std::function<void()>
|
getHcpResStrAsync(::std::function<void(::VptDetect::stringDatas)> response,
|
::std::function<void(::std::exception_ptr)> ex = nullptr,
|
::std::function<void(bool)> sent = nullptr,
|
const ::Ice::Context& context = Ice::noExplicitContext)
|
{
|
return _makeLamdaOutgoing<::VptDetect::stringDatas>(response, ex, sent, this, &VptDetect::VptDetectServerPrx::_iceI_getHcpResStr, context);
|
}
|
|
void _iceI_getHcpResStr(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::VptDetect::stringDatas>>&, const ::Ice::Context&);
|
|
static const ::std::string& ice_staticId();
|
|
protected:
|
|
VptDetectServerPrx() = default;
|
friend ::std::shared_ptr<VptDetectServerPrx> IceInternal::createProxy<VptDetectServerPrx>();
|
|
virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
|
};
|
|
}
|
|
namespace Ice
|
{
|
|
template<>
|
struct StreamableTraits<::VptDetect::RECT>
|
{
|
static const StreamHelperCategory helper = StreamHelperCategoryStruct;
|
static const int minWireSize = 16;
|
static const bool fixedLength = true;
|
};
|
|
template<typename S>
|
struct StreamReader<::VptDetect::RECT, S>
|
{
|
static void read(S* istr, ::VptDetect::RECT& v)
|
{
|
istr->readAll(v.left, v.top, v.width, v.height);
|
}
|
};
|
|
template<>
|
struct StreamableTraits<::VptDetect::ClassfyObjRes>
|
{
|
static const StreamHelperCategory helper = StreamHelperCategoryStruct;
|
static const int minWireSize = 8;
|
static const bool fixedLength = true;
|
};
|
|
template<typename S>
|
struct StreamReader<::VptDetect::ClassfyObjRes, S>
|
{
|
static void read(S* istr, ::VptDetect::ClassfyObjRes& v)
|
{
|
istr->readAll(v.res_index, v.res_prob);
|
}
|
};
|
|
template<>
|
struct StreamableTraits<::VptDetect::PersonDetectRes>
|
{
|
static const StreamHelperCategory helper = StreamHelperCategoryStruct;
|
static const int minWireSize = 1;
|
static const bool fixedLength = false;
|
};
|
|
template<typename S>
|
struct StreamReader<::VptDetect::PersonDetectRes, S>
|
{
|
static void read(S* istr, ::VptDetect::PersonDetectRes& v)
|
{
|
istr->readAll(v.res_objs);
|
}
|
};
|
|
template<>
|
struct StreamableTraits<::VptDetect::PerRideCarDetectRes>
|
{
|
static const StreamHelperCategory helper = StreamHelperCategoryStruct;
|
static const int minWireSize = 1;
|
static const bool fixedLength = false;
|
};
|
|
template<typename S>
|
struct StreamReader<::VptDetect::PerRideCarDetectRes, S>
|
{
|
static void read(S* istr, ::VptDetect::PerRideCarDetectRes& v)
|
{
|
istr->readAll(v.res_objs);
|
}
|
};
|
|
template<>
|
struct StreamableTraits<::VptDetect::CarDetectRes>
|
{
|
static const StreamHelperCategory helper = StreamHelperCategoryStruct;
|
static const int minWireSize = 46;
|
static const bool fixedLength = false;
|
};
|
|
template<typename S>
|
struct StreamReader<::VptDetect::CarDetectRes, S>
|
{
|
static void read(S* istr, ::VptDetect::CarDetectRes& v)
|
{
|
istr->readAll(v.vehicle_brand, v.vehicle_subbrand, v.vehicle_issue_year, v.vehicle_type, v.freight_ton, v.vehicle_score, v.colorLabel, v.colorLabelProb, v.carPlateRect, v.carPlateRectScore, v.carPlate, v.carPlateScore, v.carPlatetype);
|
}
|
};
|
|
template<>
|
struct StreamableTraits<::VptDetect::VptDetectResult>
|
{
|
static const StreamHelperCategory helper = StreamHelperCategoryStruct;
|
static const int minWireSize = 68;
|
static const bool fixedLength = false;
|
};
|
|
template<typename S>
|
struct StreamReader<::VptDetect::VptDetectResult, S>
|
{
|
static void read(S* istr, ::VptDetect::VptDetectResult& v)
|
{
|
istr->readAll(v.sdkDetectType, v.bskRect, v.personDetectRes, v.perRideCarDetectRes, v.carDetectRes);
|
}
|
};
|
|
}
|
|
namespace VptDetect
|
{
|
|
using VptDetectServerPtr = ::std::shared_ptr<VptDetectServer>;
|
using VptDetectServerPrxPtr = ::std::shared_ptr<VptDetectServerPrx>;
|
|
}
|
|
#else // C++98 mapping
|
|
namespace IceProxy
|
{
|
|
namespace VptDetect
|
{
|
|
class VptDetectServer;
|
void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::VptDetect::VptDetectServer>&);
|
::IceProxy::Ice::Object* upCast(::IceProxy::VptDetect::VptDetectServer*);
|
|
}
|
|
}
|
|
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
|
{
|
|
struct RECT
|
{
|
::Ice::Float left;
|
::Ice::Float top;
|
::Ice::Float width;
|
::Ice::Float height;
|
};
|
|
struct ClassfyObjRes
|
{
|
::Ice::Int res_index;
|
::Ice::Float res_prob;
|
};
|
|
typedef ::std::vector< ::VptDetect::ClassfyObjRes> ResObjs;
|
|
struct PersonDetectRes
|
{
|
::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 VptDetectResult
|
{
|
::Ice::Int sdkDetectType;
|
::VptDetect::RECT bskRect;
|
::VptDetect::PersonDetectRes personDetectRes;
|
::VptDetect::PerRideCarDetectRes perRideCarDetectRes;
|
::VptDetect::CarDetectRes carDetectRes;
|
};
|
|
typedef ::std::vector< ::VptDetect::VptDetectResult> ObjInfos;
|
|
typedef ::std::vector< ::std::string> stringData;
|
|
typedef ::std::vector< ::VptDetect::stringData> stringDatas;
|
|
}
|
|
namespace VptDetect
|
{
|
|
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 { };
|
typedef ::IceUtil::Handle< Callback_VptDetectServer_getStr_Base> Callback_VptDetectServer_getStrPtr;
|
|
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 { };
|
typedef ::IceUtil::Handle< Callback_VptDetectServer_getColorLabel_Base> Callback_VptDetectServer_getColorLabelPtr;
|
|
class Callback_VptDetectServer_getHpResStr_Base : public virtual ::IceInternal::CallbackBase { };
|
typedef ::IceUtil::Handle< Callback_VptDetectServer_getHpResStr_Base> Callback_VptDetectServer_getHpResStrPtr;
|
|
class Callback_VptDetectServer_getHcpResStr_Base : public virtual ::IceInternal::CallbackBase { };
|
typedef ::IceUtil::Handle< Callback_VptDetectServer_getHcpResStr_Base> Callback_VptDetectServer_getHcpResStrPtr;
|
|
}
|
|
namespace IceProxy
|
{
|
|
namespace VptDetect
|
{
|
|
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;
|
};
|
|
}
|
|
}
|
|
namespace VptDetect
|
{
|
|
class VptDetectServer : public virtual ::Ice::Object
|
{
|
public:
|
|
typedef VptDetectServerPrx ProxyType;
|
typedef VptDetectServerPtr PointerType;
|
|
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;
|
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&);
|
|
protected:
|
|
virtual void _iceWriteImpl(::Ice::OutputStream*) const;
|
virtual void _iceReadImpl(::Ice::InputStream*);
|
};
|
|
inline bool operator==(const VptDetectServer& lhs, const VptDetectServer& rhs)
|
{
|
return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
|
}
|
|
inline bool operator<(const VptDetectServer& lhs, const VptDetectServer& rhs)
|
{
|
return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
|
}
|
|
}
|
|
namespace Ice
|
{
|
|
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 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<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<>
|
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 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<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<>
|
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 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<typename S>
|
struct StreamWriter< ::VptDetect::VptDetectResult, S>
|
{
|
static void write(S* ostr, const ::VptDetect::VptDetectResult& v)
|
{
|
ostr->write(v.sdkDetectType);
|
ostr->write(v.bskRect);
|
ostr->write(v.personDetectRes);
|
ostr->write(v.perRideCarDetectRes);
|
ostr->write(v.carDetectRes);
|
}
|
};
|
|
template<typename S>
|
struct StreamReader< ::VptDetect::VptDetectResult, S>
|
{
|
static void read(S* istr, ::VptDetect::VptDetectResult& v)
|
{
|
istr->read(v.sdkDetectType);
|
istr->read(v.bskRect);
|
istr->read(v.personDetectRes);
|
istr->read(v.perRideCarDetectRes);
|
istr->read(v.carDetectRes);
|
}
|
};
|
|
}
|
|
namespace VptDetect
|
{
|
|
template<class 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)
|
{
|
}
|
|
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);
|
}
|
|
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);
|
}
|
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_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)
|
{
|
}
|
|
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_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);
|
}
|
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_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)
|
{
|
}
|
|
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);
|
}
|
}
|
|
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);
|
}
|
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_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)
|
{
|
}
|
|
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);
|
}
|
}
|
|
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);
|
}
|
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_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
|
