Joystick.h

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.10
//
// <auto-generated>
//
// Generated from file `Joystick.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __Joystick_h__
#define __Joystick_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 < 10
#       error Ice patch level mismatch!
#   endif
#endif
 
#ifdef ICE_CPP11_MAPPING // C++11 mapping
 
namespace Data
{
 
class CarData;
class CarDataPrx;
 
}
 
namespace Data
{
 
class CarData : public virtual ::Ice::Object
{
public:
 
    using ProxyType = CarDataPrx;

    virtual bool ice_isA(::std::string id, const ::Ice::Current& current) const override;

    virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& current) const override;

    virtual ::std::string ice_id(const ::Ice::Current& current) const override;

    static const ::std::string& ice_staticId();
 
    virtual void setJoystickValue(bool newValue, const ::Ice::Current& current) = 0;
    bool _iceD_setJoystickValue(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual bool getJoystickValue(const ::Ice::Current& current) = 0;
    bool _iceD_getJoystickValue(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void setCarTemperatureValue(double newValue, const ::Ice::Current& current) = 0;
    bool _iceD_setCarTemperatureValue(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual double getCarTemperatureValue(const ::Ice::Current& current) = 0;
    bool _iceD_getCarTemperatureValue(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
};
 
}
 
namespace Data
{
 
class CarDataPrx : public virtual ::Ice::Proxy<CarDataPrx, ::Ice::ObjectPrx>
{
public:
 
    void setJoystickValue(bool newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        _makePromiseOutgoing<void>(true, this, &CarDataPrx::_iceI_setJoystickValue, newValue, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto setJoystickValueAsync(bool newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
    {
        return _makePromiseOutgoing<void, P>(false, this, &CarDataPrx::_iceI_setJoystickValue, newValue, context);
    }
 
    ::std::function<void()>
    setJoystickValueAsync(bool newValue,
                          ::std::function<void()> response,
                          ::std::function<void(::std::exception_ptr)> ex = nullptr,
                          ::std::function<void(bool)> sent = nullptr,
                          const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Data::CarDataPrx::_iceI_setJoystickValue, newValue, context);
    }

    void _iceI_setJoystickValue(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, bool, const ::Ice::Context&);
 
    bool getJoystickValue(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<bool>(true, this, &CarDataPrx::_iceI_getJoystickValue, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getJoystickValueAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<bool>>().get_future())
    {
        return _makePromiseOutgoing<bool, P>(false, this, &CarDataPrx::_iceI_getJoystickValue, context);
    }
 
    ::std::function<void()>
    getJoystickValueAsync(::std::function<void(bool)> response,
                          ::std::function<void(::std::exception_ptr)> ex = nullptr,
                          ::std::function<void(bool)> sent = nullptr,
                          const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<bool>(std::move(response), std::move(ex), std::move(sent), this, &Data::CarDataPrx::_iceI_getJoystickValue, context);
    }

    void _iceI_getJoystickValue(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::Ice::Context&);
 
    void setCarTemperatureValue(double newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        _makePromiseOutgoing<void>(true, this, &CarDataPrx::_iceI_setCarTemperatureValue, newValue, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto setCarTemperatureValueAsync(double newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
    {
        return _makePromiseOutgoing<void, P>(false, this, &CarDataPrx::_iceI_setCarTemperatureValue, newValue, context);
    }
 
    ::std::function<void()>
    setCarTemperatureValueAsync(double newValue,
                                ::std::function<void()> response,
                                ::std::function<void(::std::exception_ptr)> ex = nullptr,
                                ::std::function<void(bool)> sent = nullptr,
                                const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &Data::CarDataPrx::_iceI_setCarTemperatureValue, newValue, context);
    }

    void _iceI_setCarTemperatureValue(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, double, const ::Ice::Context&);
 
    double getCarTemperatureValue(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<double>(true, this, &CarDataPrx::_iceI_getCarTemperatureValue, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getCarTemperatureValueAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<double>>().get_future())
    {
        return _makePromiseOutgoing<double, P>(false, this, &CarDataPrx::_iceI_getCarTemperatureValue, context);
    }
 
    ::std::function<void()>
    getCarTemperatureValueAsync(::std::function<void(double)> response,
                                ::std::function<void(::std::exception_ptr)> ex = nullptr,
                                ::std::function<void(bool)> sent = nullptr,
                                const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<double>(std::move(response), std::move(ex), std::move(sent), this, &Data::CarDataPrx::_iceI_getCarTemperatureValue, context);
    }

    void _iceI_getCarTemperatureValue(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<double>>&, const ::Ice::Context&);

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

    CarDataPrx() = default;
    friend ::std::shared_ptr<CarDataPrx> IceInternal::createProxy<CarDataPrx>();
 
    virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
};
 
}

namespace Ice
{
 
}

namespace Data
{
 
using CarDataPtr = ::std::shared_ptr<CarData>;
using CarDataPrxPtr = ::std::shared_ptr<CarDataPrx>;
 
}
 
#else // C++98 mapping
 
namespace IceProxy
{
 
namespace Data
{
 
class CarData;
void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< CarData>&);
::IceProxy::Ice::Object* upCast(CarData*);
 
}
 
}
 
namespace Data
{
 
class CarData;
::Ice::Object* upCast(CarData*);
typedef ::IceInternal::Handle< CarData> CarDataPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Data::CarData> CarDataPrx;
typedef CarDataPrx CarDataPrxPtr;
void _icePatchObjectPtr(CarDataPtr&, const ::Ice::ObjectPtr&);
 
}
 
namespace Data
{

class Callback_CarData_setJoystickValue_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_CarData_setJoystickValue_Base> Callback_CarData_setJoystickValuePtr;

class Callback_CarData_getJoystickValue_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_CarData_getJoystickValue_Base> Callback_CarData_getJoystickValuePtr;

class Callback_CarData_setCarTemperatureValue_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_CarData_setCarTemperatureValue_Base> Callback_CarData_setCarTemperatureValuePtr;

class Callback_CarData_getCarTemperatureValue_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_CarData_getCarTemperatureValue_Base> Callback_CarData_getCarTemperatureValuePtr;
 
}
 
namespace IceProxy
{
 
namespace Data
{
 
class CarData : public virtual ::Ice::Proxy<CarData, ::IceProxy::Ice::Object>
{
public:
 
    void setJoystickValue(bool newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        end_setJoystickValue(_iceI_begin_setJoystickValue(newValue, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_setJoystickValue(bool newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_setJoystickValue(newValue, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_setJoystickValue(bool newValue, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setJoystickValue(newValue, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_setJoystickValue(bool newValue, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setJoystickValue(newValue, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_setJoystickValue(bool newValue, const ::Data::Callback_CarData_setJoystickValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setJoystickValue(newValue, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_setJoystickValue(bool newValue, const ::Ice::Context& context, const ::Data::Callback_CarData_setJoystickValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setJoystickValue(newValue, context, cb, cookie);
    }
 
    void end_setJoystickValue(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ::Ice::AsyncResultPtr _iceI_begin_setJoystickValue(bool, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    bool getJoystickValue(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getJoystickValue(_iceI_begin_getJoystickValue(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getJoystickValue(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getJoystickValue(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getJoystickValue(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getJoystickValue(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getJoystickValue(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getJoystickValue(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getJoystickValue(const ::Data::Callback_CarData_getJoystickValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getJoystickValue(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getJoystickValue(const ::Ice::Context& context, const ::Data::Callback_CarData_getJoystickValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getJoystickValue(context, cb, cookie);
    }
 
    bool end_getJoystickValue(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ::Ice::AsyncResultPtr _iceI_begin_getJoystickValue(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    void setCarTemperatureValue(::Ice::Double newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        end_setCarTemperatureValue(_iceI_begin_setCarTemperatureValue(newValue, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_setCarTemperatureValue(::Ice::Double newValue, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_setCarTemperatureValue(newValue, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_setCarTemperatureValue(::Ice::Double newValue, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setCarTemperatureValue(newValue, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_setCarTemperatureValue(::Ice::Double newValue, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setCarTemperatureValue(newValue, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_setCarTemperatureValue(::Ice::Double newValue, const ::Data::Callback_CarData_setCarTemperatureValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setCarTemperatureValue(newValue, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_setCarTemperatureValue(::Ice::Double newValue, const ::Ice::Context& context, const ::Data::Callback_CarData_setCarTemperatureValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_setCarTemperatureValue(newValue, context, cb, cookie);
    }
 
    void end_setCarTemperatureValue(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ::Ice::AsyncResultPtr _iceI_begin_setCarTemperatureValue(::Ice::Double, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ::Ice::Double getCarTemperatureValue(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getCarTemperatureValue(_iceI_begin_getCarTemperatureValue(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getCarTemperatureValue(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getCarTemperatureValue(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getCarTemperatureValue(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getCarTemperatureValue(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getCarTemperatureValue(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getCarTemperatureValue(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getCarTemperatureValue(const ::Data::Callback_CarData_getCarTemperatureValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getCarTemperatureValue(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getCarTemperatureValue(const ::Ice::Context& context, const ::Data::Callback_CarData_getCarTemperatureValuePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getCarTemperatureValue(context, cb, cookie);
    }
 
    ::Ice::Double end_getCarTemperatureValue(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ::Ice::AsyncResultPtr _iceI_begin_getCarTemperatureValue(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 Data
{
 
class CarData : public virtual ::Ice::Object
{
public:
 
    typedef CarDataPrx ProxyType;
    typedef CarDataPtr PointerType;
 
    virtual ~CarData();
 
#ifdef ICE_CPP11_COMPILER
    CarData() = default;
    CarData(const CarData&) = default;
    CarData& operator=(const CarData&) = default;
#endif

    virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;

    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;

    virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;

    static const ::std::string& ice_staticId();
 
    virtual void setJoystickValue(bool newValue, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_setJoystickValue(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual bool getJoystickValue(const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_getJoystickValue(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void setCarTemperatureValue(::Ice::Double newValue, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_setCarTemperatureValue(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual ::Ice::Double getCarTemperatureValue(const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_getCarTemperatureValue(::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 CarData& lhs, const CarData& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
}
 
inline bool operator<(const CarData& lhs, const CarData& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
}
 
}

namespace Ice
{
 
}
 
namespace Data
{

template<class T>
class CallbackNC_CarData_setJoystickValue : public Callback_CarData_setJoystickValue_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:
 
    typedef IceUtil::Handle<T> TPtr;
 
    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();
 
    CallbackNC_CarData_setJoystickValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setJoystickValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setJoystickValue<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setJoystickValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setJoystickValue<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_CarData_setJoystickValue : public Callback_CarData_setJoystickValue_Base, public ::IceInternal::OnewayCallback<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 CT&);
 
    Callback_CarData_setJoystickValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setJoystickValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setJoystickValue<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setJoystickValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_setJoystickValuePtr
newCallback_CarData_setJoystickValue(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setJoystickValue<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_CarData_getJoystickValue : public Callback_CarData_getJoystickValue_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)(bool);
 
    CallbackNC_CarData_getJoystickValue(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
    {
        CarDataPrx proxy = CarDataPrx::uncheckedCast(result->getProxy());
        bool ret;
        try
        {
            ret = proxy->end_getJoystickValue(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_CarData_getJoystickValuePtr
newCallback_CarData_getJoystickValue(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_getJoystickValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_CarData_getJoystickValuePtr
newCallback_CarData_getJoystickValue(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_getJoystickValue<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_CarData_getJoystickValue : public Callback_CarData_getJoystickValue_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)(bool, const CT&);
 
    Callback_CarData_getJoystickValue(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
    {
        CarDataPrx proxy = CarDataPrx::uncheckedCast(result->getProxy());
        bool ret;
        try
        {
            ret = proxy->end_getJoystickValue(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_CarData_getJoystickValuePtr
newCallback_CarData_getJoystickValue(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_getJoystickValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_getJoystickValuePtr
newCallback_CarData_getJoystickValue(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_getJoystickValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T>
class CallbackNC_CarData_setCarTemperatureValue : public Callback_CarData_setCarTemperatureValue_Base, public ::IceInternal::OnewayCallbackNC<T>
{
public:
 
    typedef IceUtil::Handle<T> TPtr;
 
    typedef void (T::*Exception)(const ::Ice::Exception&);
    typedef void (T::*Sent)(bool);
    typedef void (T::*Response)();
 
    CallbackNC_CarData_setCarTemperatureValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

template<class T> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setCarTemperatureValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setCarTemperatureValue<T>(instance, 0, excb, sentcb);
}

template<class T> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setCarTemperatureValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_setCarTemperatureValue<T>(instance, 0, excb, sentcb);
}

template<class T, typename CT>
class Callback_CarData_setCarTemperatureValue : public Callback_CarData_setCarTemperatureValue_Base, public ::IceInternal::OnewayCallback<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 CT&);
 
    Callback_CarData_setCarTemperatureValue(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};

template<class T, typename CT> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(const IceUtil::Handle<T>& instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setCarTemperatureValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setCarTemperatureValue<T, CT>(instance, 0, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(T* instance, void (T::*cb)(const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setCarTemperatureValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_setCarTemperatureValuePtr
newCallback_CarData_setCarTemperatureValue(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_setCarTemperatureValue<T, CT>(instance, 0, excb, sentcb);
}

template<class T>
class CallbackNC_CarData_getCarTemperatureValue : public Callback_CarData_getCarTemperatureValue_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)(::Ice::Double);
 
    CallbackNC_CarData_getCarTemperatureValue(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
    {
        CarDataPrx proxy = CarDataPrx::uncheckedCast(result->getProxy());
        ::Ice::Double ret;
        try
        {
            ret = proxy->end_getCarTemperatureValue(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_CarData_getCarTemperatureValuePtr
newCallback_CarData_getCarTemperatureValue(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Double), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_getCarTemperatureValue<T>(instance, cb, excb, sentcb);
}

template<class T> Callback_CarData_getCarTemperatureValuePtr
newCallback_CarData_getCarTemperatureValue(T* instance, void (T::*cb)(::Ice::Double), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_CarData_getCarTemperatureValue<T>(instance, cb, excb, sentcb);
}

template<class T, typename CT>
class Callback_CarData_getCarTemperatureValue : public Callback_CarData_getCarTemperatureValue_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)(::Ice::Double, const CT&);
 
    Callback_CarData_getCarTemperatureValue(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
    {
        CarDataPrx proxy = CarDataPrx::uncheckedCast(result->getProxy());
        ::Ice::Double ret;
        try
        {
            ret = proxy->end_getCarTemperatureValue(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_CarData_getCarTemperatureValuePtr
newCallback_CarData_getCarTemperatureValue(const IceUtil::Handle<T>& instance, void (T::*cb)(::Ice::Double, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_getCarTemperatureValue<T, CT>(instance, cb, excb, sentcb);
}

template<class T, typename CT> Callback_CarData_getCarTemperatureValuePtr
newCallback_CarData_getCarTemperatureValue(T* instance, void (T::*cb)(::Ice::Double, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_CarData_getCarTemperatureValue<T, CT>(instance, cb, excb, sentcb);
}
 
}
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif