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