// **********************************************************************
//
// 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