ice bidir

最新推荐文章于 2022-04-14 16:02:51 发布
最新推荐文章于 2022-04-14 16:02:51 发布
阅读量784 收藏
点赞数
分类专栏： zeroc-ice
第一步: 编写ice 接口文件 ，这个例子实现了两个接口
Callback.ice 
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// **********************************************************************

#pragma once

#include <Ice/Identity.ice>

module Demo
{

interface CallbackReceiver
{
    void callback(int num);
};

interface CallbackSender
{
    void addClient(Ice::Identity ident);
};

};

第二步：Slice2cpp 生成辅助代码,客户端代码(Proxy)与服务端代码(适配器)

Callback.h Callback.cpp

Callback.h

// **********************************************************************
//
// Copyright (c) 2003-2016 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.6.3
//
// <auto-generated>
//
// Generated from file `Callback.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//

#ifndef __Callback_h__
#define __Callback_h__

#include <IceUtil/PushDisableWarnings.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/StreamHelpers.h>
#include <Ice/Proxy.h>
#include <Ice/GCObject.h>
#include <Ice/AsyncResult.h>
#include <Ice/Incoming.h>
#include <IceUtil/ScopedArray.h>
#include <IceUtil/Optional.h>
#include <Ice/StreamF.h>
#include <Ice/Identity.h>
#include <IceUtil/UndefSysMacros.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 306
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 3
#       error Ice patch level mismatch!
#   endif
#endif

namespace IceProxy
{

namespace Demo
{

class CallbackReceiver;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Demo::CallbackReceiver>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Demo::CallbackReceiver*);

class CallbackSender;
void __read(::IceInternal::BasicStream*, ::IceInternal::ProxyHandle< ::IceProxy::Demo::CallbackSender>&);
::IceProxy::Ice::Object* upCast(::IceProxy::Demo::CallbackSender*);

}

}

namespace Demo
{

class CallbackReceiver;
::Ice::Object* upCast(::Demo::CallbackReceiver*);
typedef ::IceInternal::Handle< ::Demo::CallbackReceiver> CallbackReceiverPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Demo::CallbackReceiver> CallbackReceiverPrx;
void __patch(CallbackReceiverPtr&, const ::Ice::ObjectPtr&);

class CallbackSender;
::Ice::Object* upCast(::Demo::CallbackSender*);
typedef ::IceInternal::Handle< ::Demo::CallbackSender> CallbackSenderPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::Demo::CallbackSender> CallbackSenderPrx;
void __patch(CallbackSenderPtr&, const ::Ice::ObjectPtr&);

}

namespace Demo
{

class Callback_CallbackReceiver_callback_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_CallbackReceiver_callback_Base> Callback_CallbackReceiver_callbackPtr;

class Callback_CallbackSender_addClient_Base : virtual public ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_CallbackSender_addClient_Base> Callback_CallbackSender_addClientPtr;

}

namespace IceProxy
{

namespace Demo
{

class CallbackReceiver : virtual public ::IceProxy::Ice::Object
{
public:

    void callback(::Ice::Int __p_num)
    {
        callback(__p_num, 0);
    }
    void callback(::Ice::Int __p_num, const ::Ice::Context& __ctx)
    {
        callback(__p_num, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_callback(::Ice::Int __p_num, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_callback(__p_num, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_callback(::Ice::Int __p_num, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_callback(__p_num, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_callback(::Ice::Int __p_num, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_callback(__p_num, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_callback(::Ice::Int __p_num, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_callback(__p_num, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_callback(::Ice::Int __p_num)
    {
        return begin_callback(__p_num, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_callback(::Ice::Int __p_num, const ::Ice::Context& __ctx)
    {
        return begin_callback(__p_num, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_callback(::Ice::Int __p_num, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_callback(__p_num, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_callback(::Ice::Int __p_num, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_callback(__p_num, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_callback(::Ice::Int __p_num, const ::Demo::Callback_CallbackReceiver_callbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_callback(__p_num, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_callback(::Ice::Int __p_num, const ::Ice::Context& __ctx, const ::Demo::Callback_CallbackReceiver_callbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_callback(__p_num, &__ctx, __del, __cookie);
    }

    void end_callback(const ::Ice::AsyncResultPtr&);
    
private:

    void callback(::Ice::Int, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_callback(::Ice::Int, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_secure(bool __secure) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_twoway() const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_twoway().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_oneway() const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_oneway().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_batchOneway() const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_datagram() const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_datagram().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_batchDatagram() const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_compress(bool __compress) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_timeout(int __timeout) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackReceiver> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<CallbackReceiver*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }
    
    static const ::std::string& ice_staticId();

private: 
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

class CallbackSender : virtual public ::IceProxy::Ice::Object
{
public:

    void addClient(const ::Ice::Identity& __p_ident)
    {
        addClient(__p_ident, 0);
    }
    void addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context& __ctx)
    {
        addClient(__p_ident, &__ctx);
    }
#ifdef ICE_CPP11
    ::Ice::AsyncResultPtr
    begin_addClient(const ::Ice::Identity& __p_ident, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_addClient(__p_ident, 0, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent));
    }
    ::Ice::AsyncResultPtr
    begin_addClient(const ::Ice::Identity& __p_ident, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_addClient(__p_ident, 0, ::Ice::newCallback(__completed, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context& __ctx, const ::IceInternal::Function<void ()>& __response, const ::IceInternal::Function<void (const ::Ice::Exception&)>& __exception = ::IceInternal::Function<void (const ::Ice::Exception&)>(), const ::IceInternal::Function<void (bool)>& __sent = ::IceInternal::Function<void (bool)>())
    {
        return begin_addClient(__p_ident, &__ctx, new ::IceInternal::Cpp11FnOnewayCallbackNC(__response, __exception, __sent), 0);
    }
    ::Ice::AsyncResultPtr
    begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context& __ctx, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __completed, const ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>& __sent = ::IceInternal::Function<void (const ::Ice::AsyncResultPtr&)>())
    {
        return begin_addClient(__p_ident, &__ctx, ::Ice::newCallback(__completed, __sent));
    }
#endif

    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity& __p_ident)
    {
        return begin_addClient(__p_ident, 0, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context& __ctx)
    {
        return begin_addClient(__p_ident, &__ctx, ::IceInternal::__dummyCallback, 0);
    }

    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addClient(__p_ident, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context& __ctx, const ::Ice::CallbackPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addClient(__p_ident, &__ctx, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity& __p_ident, const ::Demo::Callback_CallbackSender_addClientPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addClient(__p_ident, 0, __del, __cookie);
    }

    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context& __ctx, const ::Demo::Callback_CallbackSender_addClientPtr& __del, const ::Ice::LocalObjectPtr& __cookie = 0)
    {
        return begin_addClient(__p_ident, &__ctx, __del, __cookie);
    }

    void end_addClient(const ::Ice::AsyncResultPtr&);
    
private:

    void addClient(const ::Ice::Identity&, const ::Ice::Context*);
    ::Ice::AsyncResultPtr begin_addClient(const ::Ice::Identity&, const ::Ice::Context*, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& __cookie = 0);
    
public:
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_context(const ::Ice::Context& __context) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_context(__context).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_adapterId(const ::std::string& __id) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_adapterId(__id).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_endpoints(const ::Ice::EndpointSeq& __endpoints) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_endpoints(__endpoints).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_locatorCacheTimeout(int __timeout) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_locatorCacheTimeout(__timeout).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_connectionCached(bool __cached) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_connectionCached(__cached).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_endpointSelection(::Ice::EndpointSelectionType __est) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_endpointSelection(__est).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_secure(bool __secure) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_secure(__secure).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_preferSecure(bool __preferSecure) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_preferSecure(__preferSecure).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_router(const ::Ice::RouterPrx& __router) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_router(__router).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_locator(const ::Ice::LocatorPrx& __locator) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_locator(__locator).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_collocationOptimized(bool __co) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_collocationOptimized(__co).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_invocationTimeout(int __timeout) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_invocationTimeout(__timeout).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_twoway() const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_twoway().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_oneway() const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_oneway().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_batchOneway() const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_batchOneway().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_datagram() const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_datagram().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_batchDatagram() const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_batchDatagram().get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_compress(bool __compress) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_compress(__compress).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_timeout(int __timeout) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_timeout(__timeout).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_connectionId(const ::std::string& __id) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_connectionId(__id).get());
    }
    
    ::IceInternal::ProxyHandle<CallbackSender> ice_encodingVersion(const ::Ice::EncodingVersion& __v) const
    {
        return dynamic_cast<CallbackSender*>(::IceProxy::Ice::Object::ice_encodingVersion(__v).get());
    }
    
    static const ::std::string& ice_staticId();

private: 
    virtual ::IceProxy::Ice::Object* __newInstance() const;
};

}

}

namespace Demo
{

class CallbackReceiver : virtual public ::Ice::Object
{
public:

    typedef CallbackReceiverPrx ProxyType;
    typedef CallbackReceiverPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void callback(::Ice::Int, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___callback(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const CallbackReceiver& l, const CallbackReceiver& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const CallbackReceiver& l, const CallbackReceiver& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

class CallbackSender : virtual public ::Ice::Object
{
public:

    typedef CallbackSenderPrx ProxyType;
    typedef CallbackSenderPtr PointerType;

    virtual bool ice_isA(const ::std::string&, const ::Ice::Current& = ::Ice::Current()) const;
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& = ::Ice::Current()) const;
    virtual const ::std::string& ice_id(const ::Ice::Current& = ::Ice::Current()) const;
    static const ::std::string& ice_staticId();

    virtual void addClient(const ::Ice::Identity&, const ::Ice::Current& = ::Ice::Current()) = 0;
    ::Ice::DispatchStatus ___addClient(::IceInternal::Incoming&, const ::Ice::Current&);

    virtual ::Ice::DispatchStatus __dispatch(::IceInternal::Incoming&, const ::Ice::Current&);

protected:
    virtual void __writeImpl(::IceInternal::BasicStream*) const;
    virtual void __readImpl(::IceInternal::BasicStream*);
    using ::Ice::Object::__writeImpl;
    using ::Ice::Object::__readImpl;
};

inline bool operator==(const CallbackSender& l, const CallbackSender& r)
{
    return static_cast<const ::Ice::Object&>(l) == static_cast<const ::Ice::Object&>(r);
}

inline bool operator<(const CallbackSender& l, const CallbackSender& r)
{
    return static_cast<const ::Ice::Object&>(l) < static_cast<const ::Ice::Object&>(r);
}

}

namespace Demo
{

template<class T>
class CallbackNC_CallbackReceiver_callback : public Callback_CallbackReceiver_callback_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_CallbackReceiver_callback(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

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

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

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

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

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

template<class T, typename CT> Callback_CallbackReceiver_callbackPtr
newCallback_CallbackReceiver_callback(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_CallbackReceiver_callback<T, CT>(instance, cb, excb, sentcb);
}

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

template<class T, typename CT> Callback_CallbackReceiver_callbackPtr
newCallback_CallbackReceiver_callback(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_CallbackReceiver_callback<T, CT>(instance, cb, excb, sentcb);
}

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

template<class T>
class CallbackNC_CallbackSender_addClient : public Callback_CallbackSender_addClient_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_CallbackSender_addClient(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};

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

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

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

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

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

template<class T, typename CT> Callback_CallbackSender_addClientPtr
newCallback_CallbackSender_addClient(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_CallbackSender_addClient<T, CT>(instance, cb, excb, sentcb);
}

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

template<class T, typename CT> Callback_CallbackSender_addClientPtr
newCallback_CallbackSender_addClient(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_CallbackSender_addClient<T, CT>(instance, cb, excb, sentcb);
}

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

}

#include <IceUtil/PopDisableWarnings.h>
#endif

Callback.cpp 

// **********************************************************************
//
// Copyright (c) 2003-2016 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.6.3
//
// <auto-generated>
//
// Generated from file `Callback.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//

#include <Callback.h>
#include <IceUtil/PushDisableWarnings.h>
#include <Ice/LocalException.h>
#include <Ice/ObjectFactory.h>
#include <Ice/Outgoing.h>
#include <Ice/OutgoingAsync.h>
#include <Ice/BasicStream.h>
#include <IceUtil/Iterator.h>
#include <IceUtil/PopDisableWarnings.h>

#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 306
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 > 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 3
#       error Ice patch level mismatch!
#   endif
#endif

namespace
{

const ::std::string __Demo__CallbackReceiver__callback_name = "callback";

const ::std::string __Demo__CallbackSender__addClient_name = "addClient";

}
::IceProxy::Ice::Object* ::IceProxy::Demo::upCast(::IceProxy::Demo::CallbackReceiver* p) { return p; }

void
::IceProxy::Demo::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Demo::CallbackReceiver>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Demo::CallbackReceiver;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Demo::CallbackReceiver::callback(::Ice::Int __p_num, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Demo__CallbackReceiver__callback_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_num);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Demo::CallbackReceiver::begin_callback(::Ice::Int __p_num, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Demo__CallbackReceiver__callback_name, __del, __cookie);
    try
    {
        __result->prepare(__Demo__CallbackReceiver__callback_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_num);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Demo::CallbackReceiver::end_callback(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Demo__CallbackReceiver__callback_name);
}

const ::std::string&
IceProxy::Demo::CallbackReceiver::ice_staticId()
{
    return ::Demo::CallbackReceiver::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Demo::CallbackReceiver::__newInstance() const
{
    return new CallbackReceiver;
}
::IceProxy::Ice::Object* ::IceProxy::Demo::upCast(::IceProxy::Demo::CallbackSender* p) { return p; }

void
::IceProxy::Demo::__read(::IceInternal::BasicStream* __is, ::IceInternal::ProxyHandle< ::IceProxy::Demo::CallbackSender>& v)
{
    ::Ice::ObjectPrx proxy;
    __is->read(proxy);
    if(!proxy)
    {
        v = 0;
    }
    else
    {
        v = new ::IceProxy::Demo::CallbackSender;
        v->__copyFrom(proxy);
    }
}

void
IceProxy::Demo::CallbackSender::addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context* __ctx)
{
    ::IceInternal::Outgoing __og(this, __Demo__CallbackSender__addClient_name, ::Ice::Normal, __ctx);
    try
    {
        ::IceInternal::BasicStream* __os = __og.startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_ident);
        __og.endWriteParams();
    }
    catch(const ::Ice::LocalException& __ex)
    {
        __og.abort(__ex);
    }
    __invoke(__og);
}

::Ice::AsyncResultPtr
IceProxy::Demo::CallbackSender::begin_addClient(const ::Ice::Identity& __p_ident, const ::Ice::Context* __ctx, const ::IceInternal::CallbackBasePtr& __del, const ::Ice::LocalObjectPtr& __cookie)
{
    ::IceInternal::OutgoingAsyncPtr __result = new ::IceInternal::OutgoingAsync(this, __Demo__CallbackSender__addClient_name, __del, __cookie);
    try
    {
        __result->prepare(__Demo__CallbackSender__addClient_name, ::Ice::Normal, __ctx);
        ::IceInternal::BasicStream* __os = __result->startWriteParams(::Ice::DefaultFormat);
        __os->write(__p_ident);
        __result->endWriteParams();
        __result->invoke();
    }
    catch(const ::Ice::Exception& __ex)
    {
        __result->abort(__ex);
    }
    return __result;
}

void
IceProxy::Demo::CallbackSender::end_addClient(const ::Ice::AsyncResultPtr& __result)
{
    __end(__result, __Demo__CallbackSender__addClient_name);
}

const ::std::string&
IceProxy::Demo::CallbackSender::ice_staticId()
{
    return ::Demo::CallbackSender::ice_staticId();
}

::IceProxy::Ice::Object*
IceProxy::Demo::CallbackSender::__newInstance() const
{
    return new CallbackSender;
}

::Ice::Object* Demo::upCast(::Demo::CallbackReceiver* p) { return p; }

namespace
{
const ::std::string __Demo__CallbackReceiver_ids[2] =
{
    "::Demo::CallbackReceiver",
    "::Ice::Object"
};

}

bool
Demo::CallbackReceiver::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Demo__CallbackReceiver_ids, __Demo__CallbackReceiver_ids + 2, _s);
}

::std::vector< ::std::string>
Demo::CallbackReceiver::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Demo__CallbackReceiver_ids[0], &__Demo__CallbackReceiver_ids[2]);
}

const ::std::string&
Demo::CallbackReceiver::ice_id(const ::Ice::Current&) const
{
    return __Demo__CallbackReceiver_ids[0];
}

const ::std::string&
Demo::CallbackReceiver::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Demo::CallbackReceiver";
    return typeId;
#else
    return __Demo__CallbackReceiver_ids[0];
#endif
}

::Ice::DispatchStatus
Demo::CallbackReceiver::___callback(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Int __p_num;
    __is->read(__p_num);
    __inS.endReadParams();
    callback(__p_num, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Demo__CallbackReceiver_all[] =
{
    "callback",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Demo::CallbackReceiver::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Demo__CallbackReceiver_all, __Demo__CallbackReceiver_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Demo__CallbackReceiver_all)
    {
        case 0:
        {
            return ___callback(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Demo::CallbackReceiver::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Demo::CallbackReceiver::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void 
Demo::__patch(CallbackReceiverPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Demo::CallbackReceiverPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Demo::CallbackReceiver::ice_staticId(), v);
    }
}

::Ice::Object* Demo::upCast(::Demo::CallbackSender* p) { return p; }

namespace
{
const ::std::string __Demo__CallbackSender_ids[2] =
{
    "::Demo::CallbackSender",
    "::Ice::Object"
};

}

bool
Demo::CallbackSender::ice_isA(const ::std::string& _s, const ::Ice::Current&) const
{
    return ::std::binary_search(__Demo__CallbackSender_ids, __Demo__CallbackSender_ids + 2, _s);
}

::std::vector< ::std::string>
Demo::CallbackSender::ice_ids(const ::Ice::Current&) const
{
    return ::std::vector< ::std::string>(&__Demo__CallbackSender_ids[0], &__Demo__CallbackSender_ids[2]);
}

const ::std::string&
Demo::CallbackSender::ice_id(const ::Ice::Current&) const
{
    return __Demo__CallbackSender_ids[0];
}

const ::std::string&
Demo::CallbackSender::ice_staticId()
{
#ifdef ICE_HAS_THREAD_SAFE_LOCAL_STATIC
    static const ::std::string typeId = "::Demo::CallbackSender";
    return typeId;
#else
    return __Demo__CallbackSender_ids[0];
#endif
}

::Ice::DispatchStatus
Demo::CallbackSender::___addClient(::IceInternal::Incoming& __inS, const ::Ice::Current& __current)
{
    __checkMode(::Ice::Normal, __current.mode);
    ::IceInternal::BasicStream* __is = __inS.startReadParams();
    ::Ice::Identity __p_ident;
    __is->read(__p_ident);
    __inS.endReadParams();
    addClient(__p_ident, __current);
    __inS.__writeEmptyParams();
    return ::Ice::DispatchOK;
}

namespace
{
const ::std::string __Demo__CallbackSender_all[] =
{
    "addClient",
    "ice_id",
    "ice_ids",
    "ice_isA",
    "ice_ping"
};

}

::Ice::DispatchStatus
Demo::CallbackSender::__dispatch(::IceInternal::Incoming& in, const ::Ice::Current& current)
{
    ::std::pair< const ::std::string*, const ::std::string*> r = ::std::equal_range(__Demo__CallbackSender_all, __Demo__CallbackSender_all + 5, current.operation);
    if(r.first == r.second)
    {
        throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
    }

    switch(r.first - __Demo__CallbackSender_all)
    {
        case 0:
        {
            return ___addClient(in, current);
        }
        case 1:
        {
            return ___ice_id(in, current);
        }
        case 2:
        {
            return ___ice_ids(in, current);
        }
        case 3:
        {
            return ___ice_isA(in, current);
        }
        case 4:
        {
            return ___ice_ping(in, current);
        }
    }

    assert(false);
    throw ::Ice::OperationNotExistException(__FILE__, __LINE__, current.id, current.facet, current.operation);
}

void
Demo::CallbackSender::__writeImpl(::IceInternal::BasicStream* __os) const
{
    __os->startWriteSlice(ice_staticId(), -1, true);
    __os->endWriteSlice();
}

void
Demo::CallbackSender::__readImpl(::IceInternal::BasicStream* __is)
{
    __is->startReadSlice();
    __is->endReadSlice();
}

void 
Demo::__patch(CallbackSenderPtr& handle, const ::Ice::ObjectPtr& v)
{
    handle = ::Demo::CallbackSenderPtr::dynamicCast(v);
    if(v && !handle)
    {
        IceInternal::Ex::throwUOE(::Demo::CallbackSender::ice_staticId(), v);
    }
}

第三步：根据业务实现接口
接口CallbackSender的实现,这个接口由服务端使用,同时CallbackReceiver接口在client.cpp中实现，由客户端使用
CallbackI.h  
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// **********************************************************************

#ifndef CALLBACK_I_H
#define CALLBACK_I_H

#include <IceUtil/IceUtil.h>
#include <Callback.h>
#include <set>

class CallbackSenderI;
typedef IceUtil::Handle<CallbackSenderI> CallbackSenderIPtr;

class CallbackSenderI : public Demo::CallbackSender, public IceUtil::Thread, public IceUtil::Monitor<IceUtil::Mutex>
{
public:
    
    CallbackSenderI(const Ice::CommunicatorPtr&);

    void destroy();

    virtual void addClient(const Ice::Identity&, const Ice::Current&);

    virtual void run();

private:

    Ice::CommunicatorPtr _communicator;
    bool _destroy;
    std::set<Demo::CallbackReceiverPrx> _clients;
};

#endif

CallbackI.cpp 
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// **********************************************************************

#include <Ice/Ice.h>
#include <CallbackI.h>

using namespace std;
using namespace Ice;
using namespace Demo;

CallbackSenderI::CallbackSenderI(const Ice::CommunicatorPtr& communicator) :
    _communicator(communicator), _destroy(false)
{
}

void
CallbackSenderI::destroy()
{
    {
        IceUtil::Monitor<IceUtil::Mutex>::Lock lck(*this);

        cout << "destroying callback sender" << endl;
        _destroy = true;

        notify();
    }

    getThreadControl().join();
}

void
CallbackSenderI::addClient(const Identity& ident, const Current& current)
{
    IceUtil::Monitor<IceUtil::Mutex>::Lock lck(*this);

    cout << "adding client `" << _communicator->identityToString(ident) << "'"<< endl;

    CallbackReceiverPrx client = CallbackReceiverPrx::uncheckedCast(current.con->createProxy(ident));
    _clients.insert(client);
}

void
CallbackSenderI::run()
{
    int num = 0;
    bool destroyed = false;
    while(!destroyed)
    {
        std::set<Demo::CallbackReceiverPrx> clients;
        {
            IceUtil::Monitor<IceUtil::Mutex>::Lock lck(*this);
            timedWait(IceUtil::Time::seconds(2));

            if(_destroy)
            {
                destroyed = true;
                continue;
            }

            clients = _clients;
        }

        if(!clients.empty())
        {
            ++num;
            for(set<CallbackReceiverPrx>::iterator p = clients.begin(); p != clients.end(); ++p)
            {
                try
                {
                    (*p)->callback(num);
                }
                catch(const Exception& ex)
                {
                    cerr << "removing client `" << _communicator->identityToString((*p)->ice_getIdentity()) << "':\n"
                         << ex << endl;

                    IceUtil::Monitor<IceUtil::Mutex>::Lock lck(*this);
                    _clients.erase(*p);
                }
            }
        }
    }
}

第四步：实现客户端与服务器
客户端实际就是实现了CallbackReceiver
说明：
1) 通信器communitor()
2)得到 CallbackSenderPrx server =  communicator()->propertyToProxy("CallbackSender.Proxy")  
3)为了实现服务器回调，客户端通过 communicator() 生成了一个空的适配器，相当于将客户端变成了一个服务器
    Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("");
4)为servant  CallbackReceiverI生成id ,并加入适配器
     Ice::Identity ident;
    ident.name = IceUtil::generateUUID();
    ident.category = "";
    CallbackReceiverPtr cr = new CallbackReceiverI;
    adapter->add(cr, ident);
5) 激活适配器
    adapter->activate();
6)取客户端的通信器，并将上面的适配器加入这个通信器  server->ice_getConnection()->setAdapter(adapter);
7)将适配器做为server的客户端 
      server->addClient(ident);
8) 通信器检测事件并等待结束
    communicator()->waitForShutdown(); 

// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// **********************************************************************

#include <IceUtil/IceUtil.h>
#include <Ice/Ice.h>
#include <Callback.h>

using namespace std;
using namespace Demo;

class CallbackReceiverI : public CallbackReceiver
{
public:

    virtual void
    callback(Ice::Int num, const Ice::Current&)
    {
        cout << "received callback #" << num << endl;
    }
};

class CallbackClient : public Ice::Application
{
public:

    virtual int run(int, char*[]);
};

int
main(int argc, char* argv[])
{
    CallbackClient app;
    return app.main(argc, argv, "config.client");
}

int
CallbackClient::run(int argc, char*[])
{
    if(argc > 1)
    {
        cerr << appName() << ": too many arguments" << endl;
        return EXIT_FAILURE;
    }

    CallbackSenderPrx server = CallbackSenderPrx::checkedCast(communicator()->propertyToProxy("CallbackSender.Proxy"));
    if(!server)
    {
        cerr << appName() << ": invalid proxy" << endl;
        return EXIT_FAILURE;
    }

    Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("");
    Ice::Identity ident;
    ident.name = IceUtil::generateUUID();
    ident.category = "";
    CallbackReceiverPtr cr = new CallbackReceiverI;
    adapter->add(cr, ident);
    adapter->activate();
    server->ice_getConnection()->setAdapter(adapter);
    server->addClient(ident);
    communicator()->waitForShutdown();

    return EXIT_SUCCESS;
}

server.cpp
说明：
1) 创建适配器时，Callback.Server  对应config.server 文件中的 Callback.Server.Endpoints=tcp -p 10000:ws -p 10002
2) 创建servant CallbackSenderIPtr sender = new CallbackSenderI(communicator()); 
3）将servant 加入适配器 adapter->add(sender, communicator()->stringToIdentity("sender"));
4) 激活适配器 .  
   adapter->activate();
5) svervant CallbackSenderI 除了实现Callback.ice中定义的接口外，还继承了IceUtil::Thread IceUtil::Monitor<IceUtil::Mutex>两个类，
   使svervant CallbackSenderI  具有线程能力
    启动线程  sender->start();
6)IceUtil::Monitor<IceUtil::Mutex> 这个类还不太清楚做什么，后面再回来改吧
     
// **********************************************************************
//
// Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved.
//
// **********************************************************************

#include <Ice/Ice.h>
#include <CallbackI.h>

using namespace std;
using namespace Demo;

class CallbackServer : public Ice::Application
{
public:

    virtual int run(int, char*[]);
};

int
main(int argc, char* argv[])
{
    CallbackServer app;
    return app.main(argc, argv, "config.server");
}

int
CallbackServer::run(int argc, char*[])
{
    if(argc > 1)
    {
        cerr << appName() << ": too many arguments" << endl;
        return EXIT_FAILURE;
    }

    Ice::ObjectAdapterPtr adapter = communicator()->createObjectAdapter("Callback.Server");
    CallbackSenderIPtr sender = new CallbackSenderI(communicator());
    adapter->add(sender, communicator()->stringToIdentity("sender"));
    adapter->activate();

    sender->start();
    try
    {
        communicator()->waitForShutdown();
    }
    catch(...)
    {
        sender->destroy();
        throw;
    }
    sender->destroy();

    return EXIT_SUCCESS;
}

五 配置文件 
config.client 
#
# The client reads this property to create the reference to the
# "CallbackSender" object in the server.
#
CallbackSender.Proxy=sender:tcp -p 10000

#
# Uncomment to use the WebSocket transport instead.
#
#CallbackSender.Proxy=sender:ws -p 10002

#
# Only connect to the localhost interface by default.
#
Ice.Default.Host=localhost

#
# Warn about connection exceptions
#
Ice.Warn.Connections=1

#
# Network Tracing
#
# 0 = no network tracing
# 1 = trace connection establishment and closure
# 2 = like 1, but more detailed
# 3 = like 2, but also trace data transfer
#
#Ice.Trace.Network=1

#
# Protocol Tracing
#
# 0 = no protocol tracing
# 1 = trace protocol messages
#
#Ice.Trace.Protocol=1

config.server 
#
# The server creates one single object adapter with the name
# "Callback.Server". The following line sets the endpoints for this
# adapter.
#
Callback.Server.Endpoints=tcp -p 10000:ws -p 10002

#
# Only listen on the localhost interface by default.
#
Ice.Default.Host=localhost

#
# Warn about connection exceptions
#
Ice.Warn.Connections=1

#
# Network Tracing
#
# 0 = no network tracing
# 1 = trace connection establishment and closure
# 2 = like 1, but more detailed
# 3 = like 2, but also trace data transfer
#
#Ice.Trace.Network=1

#
# Protocol Tracing
#
# 0 = no protocol tracing
# 1 = trace protocol messages
#
#Ice.Trace.Protocol=1

六 运行结果



litterflybug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++使用ICE实现两台主机通信实例
phymat.nico的专栏
10-08 2474
ice使用过程跟google protocol buffer、gsoap类似，都是先写一个类似配置文件的东西，然后使用提供的工具生成相应语言的代码。 ice先写一个后缀名为.ice的文件，然后使用slice2cpp.exe生产对应c++代码，如下module MCal { interface Cal { int add(int num1,int num2);
AC620FPGA NIOS II学习笔记——按键控制
weixin_41738734的博客
12-25 1420
AC620FPGA NIOS II学习笔记——按键控制简介QuartusEclipse 简介 对PIO增加输入方式，在eclipse中读取按键状态，控制4个led闪烁 Quartus Bidir双向IO口（输入、输出）用于到芯片引脚 内部若是想实现双向IO需要使用 InOut Output Register选项用于是否激活独立控制单个IO口 Eclipse 代码中的PIO_BASE 是在Quar...
NIOS II——PIO寄存器分析及使用
Theresahu49的博客
04-14 1552
4个led对应一个PIO口的4bits位宽或者4个PIO口；Bidir为双向（对应于外部，接IO口），一根信号线即可输出入，而InOut则有两根信号线，接内部逻辑；初始化值1111十六进制为f 四个寄存器：data、IRQ Generation（中断）、direction、edgecapture（边沿捕获） 任务：2个按键，当按键0按下时，LED灯开始闪烁；当按键1按下时，LED灯停止闪烁。 要求：使用一个PIO，设置为6位（驱动4个LED灯和2个按键），能够捕获下降沿、产生中断（边沿）、使能单独..
inout和bidir
03-22
讲述了sopc中管角的方向，在普通管角中有inout和bidir的区别
ICE专题：ICE的5个服务
weixin_34114823的博客
05-02 201
  Summary这里介绍了ICE的五个服务         Ice为分布式开发提供了技术完善的客户-服务平台。实际上，现实的应用不仅仅只需要具备远程通讯能力，通常的，还需要随需启动服务，把代理分布到客户端，分发异步事件，配置应用，发布补丁等等。         Ice自带了一些服务，这些服务具备了上面所说的特征和一些其它的特征。这些服务实现以服务器的形式实现并向你的应用提供服务。他们分别是...
ice Callback
litterflybug的专栏
01-22 1086
一 接口描述，本例子定义了两个接口     接口 CallbackSender 中的方法 void initiateCallback(CallbackReceiver* proxy);用于向服务器传递Proxy     接口 CallbackReceiver 中的方法 void callback(); 用于服务器的回调 // *****************************
inout和bidir的区别.pdf
12-21
inout和bidir的区别.pdf
bidir_bsort.zip_冒泡排序
09-23
从头和尾同时进行冒泡排序
pimbd:Linux双栈PIM BIDIR（及更多...）实现
05-12
pimbd-PIM BIDIR双协议栈实现。 Pimb是一种PIM BIDIR实现，可实现IPv4和IPv6多播流量转发。 它支持通过IPC进行动态配置，并已集成到hnetd（HNCP实现：github.com/sbyx/hnetd/）中，以实现零配置操作。 该项目已...
嵌入式软核NiosⅡ串口直接读写寄存器的编程方法
10-25
NiosⅡ处理器是Intel公司为Altera公司推出的一个32位精简指令处理器软核。在Altera公司推出的软件SoPC中加载NiosⅡ软核和相应的外围接口以及与定义相应的自定义指令，然后对设计进行综合，下载到FPGA中就可以方便地...
ICE bidirectional connections 关键点
weixin_30662109的博客
04-24 97
ICE是一套跨平台分布式通信框架。本文介绍ICE3.4.1的bidirectional connection特性。 客户端： C++: 1: CallbackSenderPrx server = CallbackSenderPrx::checkedCast(communicator()->propertyToProxy("CallbackSender.Proxy")); 2: ...
NIOS II 2：控制多个LED（8个）(使用双向便于理解寄存器)----KEY按键，按键使用查询和边沿捕获实现
cw0617的博客
01-28 1097
里边主要讲了大概过程，详细过程请看NIOS点亮LED博客 这里主要记录多位PIO怎么控制 1、建立quartus工程，LED8 2、打开Qsys。选择如下，在NIOS控制LED博客中详细记录了这几个怎么选择 3、PIO做如下选择，位宽8.使能单个的位控制，这样可以分别控制每个LED 注意：Bidir和inout有个明显区别。使用Bidir有一个端口。使用inou有两个端口 所以如果信号外接到FPGA引脚一定要选Bidir型，如果内部使用可以inout 之后连线，generate ...
ICE详解
顺其自然~专栏
04-21 2009
1. ICE的一些背景 ICE（the Internet Communications Engine，因特网通讯引擎），http://www.zeroc.com/ice.html ICE 是ZeroC的主要产品, 是一个object-oriented toolkit,用来帮助我们构建分布式应用程序，使我们专注于程序的逻辑而不是底程网络交互的细节 ice提供了强大的 RPC(remote ...
nios ii 中双向pio的设置与读写函数
业余挖掘机学校的专栏
06-23 3901
双向pio的设置如下图，选bidir，如果选inout的话输入输出是分开的两个端口 对于bidir类型的双向pio的读写之前首先要设置pio的方向，可以用下面的函数 IOWR(base, 1, 0x0);   这个函数意思是对base所代表的pio的方向寄存器写0x0,1代表方向寄存器，写0x0代表所有的位（比如上面的共16位）都为输入 执行完上面的指令后就可以用IORD(base）
ICE的proxy使用
顺其自然~专栏
04-24 967
1、在ICE的客户端获取代理的方式如下： A、Ice::ObjectPrx p = communicator->stirngToProxy("MyProxy:tcp -h 10.0.0.1 -p 12345"); 注：MyProxy:tcp -h 10.0.0.1 -p 12345 远程服务单元名称:协议 -h 主机 -p 端口号 B、Ice::ObjectPrx p ...
ICE 网络库尝试
Monkeycn的专栏
07-30 4467
<br />1.编写 ice 对象定义文件Printer.ice：<br /> <br />// **********************************************************************<br />//<br />// Copyright (c) 2003-2010 ZeroC, Inc. All rights reserved.<br />//<br />// This copy of Ice is licensed to you under the t
ice hello
litterflybug的专栏
01-20 841
第一步：写ice 接口描述语言 （Hello.ice)// ********************************************************************** // // Copyright (c) 2003-2016 ZeroC, Inc. All rights reserved. // // ******************************
在期中大作业的基础上，实现一个中文分词类，要求： 完成类的定义 实例化类时加载字典 分别实现3种成员方法：正向、逆向和双向最大匹配分词算法 # 定义一个分词类 class Segment: # 代码实现 调用测试： # 定义字典 dicts = {"我们", "项目", "研究", "研究生", "生命", "起源", "大学", "学生", "生活", "充实"} # 定义待切分句子 text = "我们的项目是研究生命的起源" # 实例化一个Segment对象 segment = Segment(dicts) # 调用方法进行分词 print( segment.left_cut(text), segment.right_cut(text), segment.bidir_cut(text), sep="\n" )
最新发布
05-17
`bidir_cut` 方法则是双向最大匹配算法，其实现过程是先分别用正向和逆向最大匹配算法得到两个结果，然后比较它们的长度和词语长度之和，选择得分更低（即切分错误更少）的结果。 以下是代码的使用示例： ```...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值