IceStormInternal.h

Go to the documentation of this file.

// **********************************************************************
//
// 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 `IceStormInternal.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __IceStorm_IceStormInternal_h__
#define __IceStorm_IceStormInternal_h__
 
#include <deque>
 
#include <Ice/Comparable.h>
#include <Ice/Current.h>
#include <Ice/Exception.h>
#include <Ice/ExceptionHelpers.h>
#include <Ice/FactoryTableInit.h>
#include <Ice/GCObject.h>
#include <Ice/Incoming.h>
#include <Ice/LocalObject.h>
#include <Ice/Object.h>
#include <Ice/ObjectF.h>
#include <Ice/Optional.h>
#include <Ice/Proxy.h>
#include <Ice/ProxyF.h>
#include <Ice/StreamHelpers.h>
#include <Ice/Value.h>
#include <Ice/ValueF.h>
#include <IceStorm/Election.h>
#include <IceStorm/IceStorm.h>
#include <IceUtil/PushDisableWarnings.h>
#include <IceUtil/ScopedArray.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 IceStorm
{
 
    class TopicLink;
    class TopicLinkPrx;
    class TopicInternal;
    class TopicInternalPrx;
    class TopicManagerInternal;
    class TopicManagerInternalPrx;
 
} // namespace IceStorm
 
namespace IceStorm
{
 
    struct EventData
    {
        ::std::string op;
        ::Ice::OperationMode mode;
        ::Ice::ByteSeq data;
        ::Ice::Context context;
 
        std::tuple<const ::std::string&,
                   const ::Ice::OperationMode&,
                   const ::Ice::ByteSeq&,
                   const ::Ice::Context&>
        ice_tuple() const
        {
            return std::tie(op, mode, data, context);
        }
    };
 
    class SendQueueSizeMaxReached :
        public ::Ice::LocalExceptionHelper<SendQueueSizeMaxReached, ::Ice::LocalException>
    {
    public:
        virtual ~SendQueueSizeMaxReached();
 
        SendQueueSizeMaxReached(const SendQueueSizeMaxReached&) = default;
 
        SendQueueSizeMaxReached(const char* file_, int line_) :
            ::Ice::LocalExceptionHelper<SendQueueSizeMaxReached, ::Ice::LocalException>(file_,
                                                                                        line_)
        {
        }
 
        std::tuple<>
        ice_tuple() const
        {
            return std::tie();
        }
 
        static const ::std::string& ice_staticId();
    };
 
    using EventDataSeq = std::deque<::IceStorm::EventDataPtr>;
 
    class ReapWouldBlock : public ::Ice::UserExceptionHelper<ReapWouldBlock, ::Ice::UserException>
    {
    public:
        virtual ~ReapWouldBlock();
 
        ReapWouldBlock(const ReapWouldBlock&) = default;
 
        ReapWouldBlock() = default;
 
        std::tuple<>
        ice_tuple() const
        {
            return std::tie();
        }
 
        static const ::std::string& ice_staticId();
    };
 
    static ReapWouldBlock _iceS_ReapWouldBlock_init;
 
    using Ice::operator<;
    using Ice::operator<=;
    using Ice::operator>;
    using Ice::operator>=;
    using Ice::operator==;
    using Ice::operator!=;
 
} // namespace IceStorm
 
namespace IceStorm
{
 
    class TopicLink : public virtual ::Ice::Object
    {
    public:
        using ProxyType = TopicLinkPrx;
 
        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 void forward(::IceStorm::EventDataSeq, const ::Ice::Current&) = 0;
        bool _iceD_forward(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
    };
 
    class TopicInternal : public virtual ::IceStorm::Topic
    {
    public:
        using ProxyType = TopicInternalPrx;
 
        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 ::std::shared_ptr<::IceStorm::TopicLinkPrx> getLinkProxy(const ::Ice::Current&) = 0;
        bool _iceD_getLinkProxy(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void reap(::Ice::IdentitySeq, const ::Ice::Current&) = 0;
        bool _iceD_reap(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
    };
 
    class TopicManagerInternal : public virtual ::IceStorm::TopicManager
    {
    public:
        using ProxyType = TopicManagerInternalPrx;
 
        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 ::std::shared_ptr<::IceStormElection::NodePrx>
        getReplicaNode(const ::Ice::Current&) const = 0;
        bool _iceD_getReplicaNode(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
    };
 
} // namespace IceStorm
 
namespace IceStorm
{
 
    class TopicLinkPrx : public virtual ::Ice::Proxy<TopicLinkPrx, ::Ice::ObjectPrx>
    {
    public:
        void
        forward(const ::IceStorm::EventDataSeq& iceP_events,
                const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(
                true, this, &IceStorm::TopicLinkPrx::_iceI_forward, iceP_events, context)
                .get();
        }
 
        template <template <typename> class P = ::std::promise>
        auto
        forwardAsync(const ::IceStorm::EventDataSeq& iceP_events,
                     const ::Ice::Context& context = Ice::noExplicitContext)
            -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(
                false, this, &IceStorm::TopicLinkPrx::_iceI_forward, iceP_events, context);
        }
 
        ::std::function<void()>
        forwardAsync(const ::IceStorm::EventDataSeq& iceP_events,
                     ::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>(response,
                                            ex,
                                            sent,
                                            this,
                                            &IceStorm::TopicLinkPrx::_iceI_forward,
                                            iceP_events,
                                            context);
        }
 
        void _iceI_forward(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&,
                           const ::IceStorm::EventDataSeq&,
                           const ::Ice::Context&);
 
        static const ::std::string& ice_staticId();
 
    protected:
        TopicLinkPrx() = default;
        friend ::std::shared_ptr<TopicLinkPrx> IceInternal::createProxy<TopicLinkPrx>();
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
    };
 
    class TopicInternalPrx : public virtual ::Ice::Proxy<TopicInternalPrx, ::IceStorm::TopicPrx>
    {
    public:
        ::std::shared_ptr<::IceStorm::TopicLinkPrx>
        getLinkProxy(const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicLinkPrx>>(
                       true, this, &IceStorm::TopicInternalPrx::_iceI_getLinkProxy, context)
                .get();
        }
 
        template <template <typename> class P = ::std::promise>
        auto
        getLinkProxyAsync(const ::Ice::Context& context = Ice::noExplicitContext)
            -> decltype(::std::declval<P<::std::shared_ptr<::IceStorm::TopicLinkPrx>>>()
                            .get_future())
        {
            return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicLinkPrx>, P>(
                false, this, &IceStorm::TopicInternalPrx::_iceI_getLinkProxy, context);
        }
 
        ::std::function<void()>
        getLinkProxyAsync(
            ::std::function<void(::std::shared_ptr<::IceStorm::TopicLinkPrx>)> response,
            ::std::function<void(::std::exception_ptr)> ex = nullptr,
            ::std::function<void(bool)> sent = nullptr,
            const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makeLamdaOutgoing<::std::shared_ptr<::IceStorm::TopicLinkPrx>>(
                response, ex, sent, this, &IceStorm::TopicInternalPrx::_iceI_getLinkProxy, context);
        }
 
        void _iceI_getLinkProxy(
            const ::std::shared_ptr<
                ::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStorm::TopicLinkPrx>>>&,
            const ::Ice::Context&);
 
        void
        reap(const ::Ice::IdentitySeq& iceP_id,
             const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(
                true, this, &IceStorm::TopicInternalPrx::_iceI_reap, iceP_id, context)
                .get();
        }
 
        template <template <typename> class P = ::std::promise>
        auto
        reapAsync(const ::Ice::IdentitySeq& iceP_id,
                  const ::Ice::Context& context = Ice::noExplicitContext)
            -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(
                false, this, &IceStorm::TopicInternalPrx::_iceI_reap, iceP_id, context);
        }
 
        ::std::function<void()>
        reapAsync(const ::Ice::IdentitySeq& iceP_id,
                  ::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>(response,
                                            ex,
                                            sent,
                                            this,
                                            &IceStorm::TopicInternalPrx::_iceI_reap,
                                            iceP_id,
                                            context);
        }
 
        void _iceI_reap(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&,
                        const ::Ice::IdentitySeq&,
                        const ::Ice::Context&);
 
        static const ::std::string& ice_staticId();
 
    protected:
        TopicInternalPrx() = default;
        friend ::std::shared_ptr<TopicInternalPrx> IceInternal::createProxy<TopicInternalPrx>();
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
    };
 
    class TopicManagerInternalPrx :
        public virtual ::Ice::Proxy<TopicManagerInternalPrx, ::IceStorm::TopicManagerPrx>
    {
    public:
        ::std::shared_ptr<::IceStormElection::NodePrx>
        getReplicaNode(const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<::std::shared_ptr<::IceStormElection::NodePrx>>(
                       true,
                       this,
                       &IceStorm::TopicManagerInternalPrx::_iceI_getReplicaNode,
                       context)
                .get();
        }
 
        template <template <typename> class P = ::std::promise>
        auto
        getReplicaNodeAsync(const ::Ice::Context& context = Ice::noExplicitContext)
            -> decltype(::std::declval<P<::std::shared_ptr<::IceStormElection::NodePrx>>>()
                            .get_future())
        {
            return _makePromiseOutgoing<::std::shared_ptr<::IceStormElection::NodePrx>, P>(
                false, this, &IceStorm::TopicManagerInternalPrx::_iceI_getReplicaNode, context);
        }
 
        ::std::function<void()>
        getReplicaNodeAsync(
            ::std::function<void(::std::shared_ptr<::IceStormElection::NodePrx>)> response,
            ::std::function<void(::std::exception_ptr)> ex = nullptr,
            ::std::function<void(bool)> sent = nullptr,
            const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makeLamdaOutgoing<::std::shared_ptr<::IceStormElection::NodePrx>>(
                response,
                ex,
                sent,
                this,
                &IceStorm::TopicManagerInternalPrx::_iceI_getReplicaNode,
                context);
        }
 
        void _iceI_getReplicaNode(
            const ::std::shared_ptr<
                ::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStormElection::NodePrx>>>&,
            const ::Ice::Context&);
 
        static const ::std::string& ice_staticId();
 
    protected:
        TopicManagerInternalPrx() = default;
        friend ::std::shared_ptr<TopicManagerInternalPrx>
        IceInternal::createProxy<TopicManagerInternalPrx>();
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
    };
 
} // namespace IceStorm
 
namespace Ice
{
 
    template <>
    struct StreamableTraits<::IceStorm::EventData>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 4;
        static const bool fixedLength = false;
    };
 
    template <typename S>
    struct StreamReader<::IceStorm::EventData, S>
    {
        static void
        read(S* istr, ::IceStorm::EventData& v)
        {
            istr->readAll(v.op, v.mode, v.data, v.context);
        }
    };
 
} // namespace Ice
 
namespace IceStorm
{
 
    using TopicLinkPtr = ::std::shared_ptr<TopicLink>;
    using TopicLinkPrxPtr = ::std::shared_ptr<TopicLinkPrx>;
 
    using TopicInternalPtr = ::std::shared_ptr<TopicInternal>;
    using TopicInternalPrxPtr = ::std::shared_ptr<TopicInternalPrx>;
 
    using TopicManagerInternalPtr = ::std::shared_ptr<TopicManagerInternal>;
    using TopicManagerInternalPrxPtr = ::std::shared_ptr<TopicManagerInternalPrx>;
 
} // namespace IceStorm
 
#else // C++98 mapping
 
namespace IceProxy::IceStorm
{
 
    class TopicLink;
    void _readProxy(::Ice::InputStream*,
                    ::IceInternal::ProxyHandle<::IceProxy::IceStorm::TopicLink>&);
    ::IceProxy::Ice::Object* upCast(::IceProxy::IceStorm::TopicLink*);
 
    class TopicInternal;
    void _readProxy(::Ice::InputStream*,
                    ::IceInternal::ProxyHandle<::IceProxy::IceStorm::TopicInternal>&);
    ::IceProxy::Ice::Object* upCast(::IceProxy::IceStorm::TopicInternal*);
 
    class TopicManagerInternal;
    void _readProxy(::Ice::InputStream*,
                    ::IceInternal::ProxyHandle<::IceProxy::IceStorm::TopicManagerInternal>&);
    ::IceProxy::Ice::Object* upCast(::IceProxy::IceStorm::TopicManagerInternal*);
 
} // namespace IceProxy::IceStorm
 
namespace IceStorm
{
 
    class TopicLink;
    ::Ice::Object* upCast(::IceStorm::TopicLink*);
    typedef ::IceInternal::Handle<::IceStorm::TopicLink> TopicLinkPtr;
    typedef ::IceInternal::ProxyHandle<::IceProxy::IceStorm::TopicLink> TopicLinkPrx;
    typedef TopicLinkPrx TopicLinkPrxPtr;
    void _icePatchObjectPtr(TopicLinkPtr&, const ::Ice::ObjectPtr&);
 
    class TopicInternal;
    ::Ice::Object* upCast(::IceStorm::TopicInternal*);
    typedef ::IceInternal::Handle<::IceStorm::TopicInternal> TopicInternalPtr;
    typedef ::IceInternal::ProxyHandle<::IceProxy::IceStorm::TopicInternal> TopicInternalPrx;
    typedef TopicInternalPrx TopicInternalPrxPtr;
    void _icePatchObjectPtr(TopicInternalPtr&, const ::Ice::ObjectPtr&);
 
    class TopicManagerInternal;
    ::Ice::Object* upCast(::IceStorm::TopicManagerInternal*);
    typedef ::IceInternal::Handle<::IceStorm::TopicManagerInternal> TopicManagerInternalPtr;
    typedef ::IceInternal::ProxyHandle<::IceProxy::IceStorm::TopicManagerInternal>
        TopicManagerInternalPrx;
    typedef TopicManagerInternalPrx TopicManagerInternalPrxPtr;
    void _icePatchObjectPtr(TopicManagerInternalPtr&, const ::Ice::ObjectPtr&);
 
} // namespace IceStorm
 
namespace IceStorm
{
 
    class EventData : public IceUtil::Shared
    {
    public:
        EventData()
        {
        }
 
        EventData(const ::std::string& iceP_op,
                  ::Ice::OperationMode iceP_mode,
                  const ::Ice::ByteSeq& iceP_data,
                  const ::Ice::Context& iceP_context) :
            op(iceP_op), mode(iceP_mode), data(iceP_data), context(iceP_context)
        {
        }
 
        ::std::string op;
        ::Ice::OperationMode mode;
        ::Ice::ByteSeq data;
        ::Ice::Context context;
    };
 
    typedef ::IceUtil::Handle<::IceStorm::EventData> EventDataPtr;
 
    class SendQueueSizeMaxReached : public ::Ice::LocalException
    {
    public:
        SendQueueSizeMaxReached(const char*, int);
        virtual ~SendQueueSizeMaxReached() throw();
 
        virtual ::std::string ice_id() const;
        virtual SendQueueSizeMaxReached* ice_clone() const;
        virtual void ice_throw() const;
    };
 
    typedef std::deque<::IceStorm::EventDataPtr> EventDataSeq;
 
    class ReapWouldBlock : public ::Ice::UserException
    {
    public:
        ReapWouldBlock()
        {
        }
 
        virtual ~ReapWouldBlock() throw();
 
        virtual ::std::string ice_id() const;
        virtual ReapWouldBlock* ice_clone() const;
        virtual void ice_throw() const;
 
    protected:
        virtual void _writeImpl(::Ice::OutputStream*) const;
        virtual void _readImpl(::Ice::InputStream*);
    };
 
    static ReapWouldBlock _iceS_ReapWouldBlock_init;
 
} // namespace IceStorm
 
namespace IceStorm
{
 
    class Callback_TopicLink_forward_Base : public virtual ::IceInternal::CallbackBase
    {
    };
 
    typedef ::IceUtil::Handle<Callback_TopicLink_forward_Base> Callback_TopicLink_forwardPtr;
 
    class Callback_TopicInternal_getLinkProxy_Base : public virtual ::IceInternal::CallbackBase
    {
    };
 
    typedef ::IceUtil::Handle<Callback_TopicInternal_getLinkProxy_Base>
        Callback_TopicInternal_getLinkProxyPtr;
 
    class Callback_TopicInternal_reap_Base : public virtual ::IceInternal::CallbackBase
    {
    };
 
    typedef ::IceUtil::Handle<Callback_TopicInternal_reap_Base> Callback_TopicInternal_reapPtr;
 
    class Callback_TopicManagerInternal_getReplicaNode_Base :
        public virtual ::IceInternal::CallbackBase
    {
    };
 
    typedef ::IceUtil::Handle<Callback_TopicManagerInternal_getReplicaNode_Base>
        Callback_TopicManagerInternal_getReplicaNodePtr;
 
} // namespace IceStorm
 
namespace IceProxy::IceStorm
{
 
    class TopicLink : public virtual ::Ice::Proxy<TopicLink, ::IceProxy::Ice::Object>
    {
    public:
        void
        forward(const ::IceStorm::EventDataSeq& iceP_events,
                const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_forward(
                _iceI_begin_forward(iceP_events, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr
        begin_forward(const ::IceStorm::EventDataSeq& iceP_events,
                      const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_forward(iceP_events, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr
        begin_forward(const ::IceStorm::EventDataSeq& iceP_events,
                      const ::Ice::CallbackPtr& del,
                      const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_forward(iceP_events, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_forward(const ::IceStorm::EventDataSeq& iceP_events,
                      const ::Ice::Context& context,
                      const ::Ice::CallbackPtr& del,
                      const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_forward(iceP_events, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_forward(const ::IceStorm::EventDataSeq& iceP_events,
                      const ::IceStorm::Callback_TopicLink_forwardPtr& del,
                      const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_forward(iceP_events, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_forward(const ::IceStorm::EventDataSeq& iceP_events,
                      const ::Ice::Context& context,
                      const ::IceStorm::Callback_TopicLink_forwardPtr& del,
                      const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_forward(iceP_events, context, del, cookie);
        }
 
        void end_forward(const ::Ice::AsyncResultPtr&);
 
    private:
        ::Ice::AsyncResultPtr _iceI_begin_forward(const ::IceStorm::EventDataSeq&,
                                                  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;
    };
 
    class TopicInternal : public virtual ::Ice::Proxy<TopicInternal, ::IceProxy::IceStorm::Topic>
    {
    public:
        ::IceStorm::TopicLinkPrx
        getLinkProxy(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_getLinkProxy(
                _iceI_begin_getLinkProxy(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr
        begin_getLinkProxy(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_getLinkProxy(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr
        begin_getLinkProxy(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getLinkProxy(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_getLinkProxy(const ::Ice::Context& context,
                           const ::Ice::CallbackPtr& del,
                           const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getLinkProxy(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_getLinkProxy(const ::IceStorm::Callback_TopicInternal_getLinkProxyPtr& del,
                           const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getLinkProxy(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_getLinkProxy(const ::Ice::Context& context,
                           const ::IceStorm::Callback_TopicInternal_getLinkProxyPtr& del,
                           const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getLinkProxy(context, del, cookie);
        }
 
        ::IceStorm::TopicLinkPrx end_getLinkProxy(const ::Ice::AsyncResultPtr&);
 
    private:
        ::Ice::AsyncResultPtr _iceI_begin_getLinkProxy(const ::Ice::Context&,
                                                       const ::IceInternal::CallbackBasePtr&,
                                                       const ::Ice::LocalObjectPtr& cookie = 0,
                                                       bool sync = false);
 
    public:
        void
        reap(const ::Ice::IdentitySeq& iceP_id,
             const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_reap(_iceI_begin_reap(iceP_id, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr
        begin_reap(const ::Ice::IdentitySeq& iceP_id,
                   const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_reap(iceP_id, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr
        begin_reap(const ::Ice::IdentitySeq& iceP_id,
                   const ::Ice::CallbackPtr& del,
                   const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_reap(iceP_id, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_reap(const ::Ice::IdentitySeq& iceP_id,
                   const ::Ice::Context& context,
                   const ::Ice::CallbackPtr& del,
                   const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_reap(iceP_id, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_reap(const ::Ice::IdentitySeq& iceP_id,
                   const ::IceStorm::Callback_TopicInternal_reapPtr& del,
                   const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_reap(iceP_id, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_reap(const ::Ice::IdentitySeq& iceP_id,
                   const ::Ice::Context& context,
                   const ::IceStorm::Callback_TopicInternal_reapPtr& del,
                   const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_reap(iceP_id, context, del, cookie);
        }
 
        void end_reap(const ::Ice::AsyncResultPtr&);
 
    private:
        ::Ice::AsyncResultPtr _iceI_begin_reap(const ::Ice::IdentitySeq&,
                                               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;
    };
 
    class TopicManagerInternal :
        public virtual ::Ice::Proxy<TopicManagerInternal, ::IceProxy::IceStorm::TopicManager>
    {
    public:
        ::IceStormElection::NodePrx
        getReplicaNode(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_getReplicaNode(
                _iceI_begin_getReplicaNode(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr
        begin_getReplicaNode(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_getReplicaNode(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr
        begin_getReplicaNode(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getReplicaNode(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_getReplicaNode(const ::Ice::Context& context,
                             const ::Ice::CallbackPtr& del,
                             const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getReplicaNode(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_getReplicaNode(const ::IceStorm::Callback_TopicManagerInternal_getReplicaNodePtr& del,
                             const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getReplicaNode(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr
        begin_getReplicaNode(const ::Ice::Context& context,
                             const ::IceStorm::Callback_TopicManagerInternal_getReplicaNodePtr& del,
                             const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getReplicaNode(context, del, cookie);
        }
 
        ::IceStormElection::NodePrx end_getReplicaNode(const ::Ice::AsyncResultPtr&);
 
    private:
        ::Ice::AsyncResultPtr _iceI_begin_getReplicaNode(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 IceProxy::IceStorm
 
namespace IceStorm
{
 
    class TopicLink : public virtual ::Ice::Object
    {
    public:
        typedef TopicLinkPrx ProxyType;
        typedef TopicLinkPtr PointerType;
 
        virtual ~TopicLink();
 
        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 void forward(const ::IceStorm::EventDataSeq&,
                             const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_forward(::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 TopicLink& lhs, const TopicLink& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
    }
 
    inline bool
    operator<(const TopicLink& lhs, const TopicLink& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
    }
 
    class TopicInternal : virtual public ::IceStorm::Topic
    {
    public:
        typedef TopicInternalPrx ProxyType;
        typedef TopicInternalPtr PointerType;
 
        virtual ~TopicInternal();
 
        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 ::IceStorm::TopicLinkPrx
        getLinkProxy(const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_getLinkProxy(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void reap(const ::Ice::IdentitySeq&,
                          const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_reap(::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 TopicInternal& lhs, const TopicInternal& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
    }
 
    inline bool
    operator<(const TopicInternal& lhs, const TopicInternal& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
    }
 
    class TopicManagerInternal : virtual public ::IceStorm::TopicManager
    {
    public:
        typedef TopicManagerInternalPrx ProxyType;
        typedef TopicManagerInternalPtr PointerType;
 
        virtual ~TopicManagerInternal();
 
        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 ::IceStormElection::NodePrx
        getReplicaNode(const ::Ice::Current& = ::Ice::emptyCurrent) const = 0;
        bool _iceD_getReplicaNode(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&);
 
    protected:
        virtual void _iceWriteImpl(::Ice::OutputStream*) const;
        virtual void _iceReadImpl(::Ice::InputStream*);
    };
 
    inline bool
    operator==(const TopicManagerInternal& lhs, const TopicManagerInternal& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
    }
 
    inline bool
    operator<(const TopicManagerInternal& lhs, const TopicManagerInternal& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
    }
 
} // namespace IceStorm
 
namespace Ice
{
 
    template <>
    struct StreamableTraits<::IceStorm::EventDataPtr>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStructClass;
        static const int minWireSize = 4;
        static const bool fixedLength = false;
    };
 
    template <typename S>
    struct StreamWriter<::IceStorm::EventDataPtr, S>
    {
        static void
        write(S* ostr, const ::IceStorm::EventDataPtr& v)
        {
            ostr->write(v->op);
            ostr->write(v->mode);
            ostr->write(v->data);
            ostr->write(v->context);
        }
    };
 
    template <typename S>
    struct StreamReader<::IceStorm::EventDataPtr, S>
    {
        static void
        read(S* istr, ::IceStorm::EventDataPtr& v)
        {
            istr->read(v->op);
            istr->read(v->mode);
            istr->read(v->data);
            istr->read(v->context);
        }
    };
 
    template <>
    struct StreamableTraits<::IceStorm::ReapWouldBlock>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryUserException;
    };
 
} // namespace Ice
 
namespace IceStorm
{
 
    template <class T>
    class CallbackNC_TopicLink_forward :
        public Callback_TopicLink_forward_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_TopicLink_forward(const TPtr& obj, Response cb, Exception excb, Sent sentcb) :
            ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template <class T>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(const IceUtil::Handle<T>& instance,
                                  void (T::*cb)(),
                                  void (T::*excb)(const ::Ice::Exception&),
                                  void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicLink_forward<T>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(const IceUtil::Handle<T>& instance,
                                  void (T::*excb)(const ::Ice::Exception&),
                                  void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicLink_forward<T>(instance, 0, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(T* instance,
                                  void (T::*cb)(),
                                  void (T::*excb)(const ::Ice::Exception&),
                                  void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicLink_forward<T>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(T* instance,
                                  void (T::*excb)(const ::Ice::Exception&),
                                  void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicLink_forward<T>(instance, 0, excb, sentcb);
    }
 
    template <class T, typename CT>
    class Callback_TopicLink_forward :
        public Callback_TopicLink_forward_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_TopicLink_forward(const TPtr& obj, Response cb, Exception excb, Sent sentcb) :
            ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template <class T, typename CT>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(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_TopicLink_forward<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(const IceUtil::Handle<T>& instance,
                                  void (T::*excb)(const ::Ice::Exception&, const CT&),
                                  void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicLink_forward<T, CT>(instance, 0, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(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_TopicLink_forward<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicLink_forwardPtr
    newCallback_TopicLink_forward(T* instance,
                                  void (T::*excb)(const ::Ice::Exception&, const CT&),
                                  void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicLink_forward<T, CT>(instance, 0, excb, sentcb);
    }
 
    template <class T>
    class CallbackNC_TopicInternal_getLinkProxy :
        public Callback_TopicInternal_getLinkProxy_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 ::IceStorm::TopicLinkPrx&);
 
        CallbackNC_TopicInternal_getLinkProxy(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
        {
            ::IceStorm::TopicInternalPrx proxy =
                ::IceStorm::TopicInternalPrx::uncheckedCast(result->getProxy());
            ::IceStorm::TopicLinkPrx ret;
            try
            {
                ret = proxy->end_getLinkProxy(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_TopicInternal_getLinkProxyPtr
    newCallback_TopicInternal_getLinkProxy(const IceUtil::Handle<T>& instance,
                                           void (T::*cb)(const ::IceStorm::TopicLinkPrx&),
                                           void (T::*excb)(const ::Ice::Exception&),
                                           void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicInternal_getLinkProxy<T>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicInternal_getLinkProxyPtr
    newCallback_TopicInternal_getLinkProxy(T* instance,
                                           void (T::*cb)(const ::IceStorm::TopicLinkPrx&),
                                           void (T::*excb)(const ::Ice::Exception&),
                                           void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicInternal_getLinkProxy<T>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    class Callback_TopicInternal_getLinkProxy :
        public Callback_TopicInternal_getLinkProxy_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 ::IceStorm::TopicLinkPrx&, const CT&);
 
        Callback_TopicInternal_getLinkProxy(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
        {
            ::IceStorm::TopicInternalPrx proxy =
                ::IceStorm::TopicInternalPrx::uncheckedCast(result->getProxy());
            ::IceStorm::TopicLinkPrx ret;
            try
            {
                ret = proxy->end_getLinkProxy(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_TopicInternal_getLinkProxyPtr
    newCallback_TopicInternal_getLinkProxy(const IceUtil::Handle<T>& instance,
                                           void (T::*cb)(const ::IceStorm::TopicLinkPrx&,
                                                         const CT&),
                                           void (T::*excb)(const ::Ice::Exception&, const CT&),
                                           void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicInternal_getLinkProxy<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicInternal_getLinkProxyPtr
    newCallback_TopicInternal_getLinkProxy(T* instance,
                                           void (T::*cb)(const ::IceStorm::TopicLinkPrx&,
                                                         const CT&),
                                           void (T::*excb)(const ::Ice::Exception&, const CT&),
                                           void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicInternal_getLinkProxy<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    class CallbackNC_TopicInternal_reap :
        public Callback_TopicInternal_reap_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)();
 
        CallbackNC_TopicInternal_reap(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
        {
            ::IceStorm::TopicInternalPrx proxy =
                ::IceStorm::TopicInternalPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_reap(result);
            }
            catch (const ::Ice::Exception& ex)
            {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response)
            {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)();
            }
        }
 
    private:
        Response _response;
    };
 
    template <class T>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(const IceUtil::Handle<T>& instance,
                                   void (T::*cb)(),
                                   void (T::*excb)(const ::Ice::Exception&),
                                   void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicInternal_reap<T>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(const IceUtil::Handle<T>& instance,
                                   void (T::*excb)(const ::Ice::Exception&),
                                   void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicInternal_reap<T>(instance, 0, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(T* instance,
                                   void (T::*cb)(),
                                   void (T::*excb)(const ::Ice::Exception&),
                                   void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicInternal_reap<T>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(T* instance,
                                   void (T::*excb)(const ::Ice::Exception&),
                                   void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicInternal_reap<T>(instance, 0, excb, sentcb);
    }
 
    template <class T, typename CT>
    class Callback_TopicInternal_reap :
        public Callback_TopicInternal_reap_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 CT&);
 
        Callback_TopicInternal_reap(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
        {
            ::IceStorm::TopicInternalPrx proxy =
                ::IceStorm::TopicInternalPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_reap(result);
            }
            catch (const ::Ice::Exception& ex)
            {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response)
            {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(
                    CT::dynamicCast(result->getCookie()));
            }
        }
 
    private:
        Response _response;
    };
 
    template <class T, typename CT>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(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_TopicInternal_reap<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(const IceUtil::Handle<T>& instance,
                                   void (T::*excb)(const ::Ice::Exception&, const CT&),
                                   void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicInternal_reap<T, CT>(instance, 0, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(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_TopicInternal_reap<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicInternal_reapPtr
    newCallback_TopicInternal_reap(T* instance,
                                   void (T::*excb)(const ::Ice::Exception&, const CT&),
                                   void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicInternal_reap<T, CT>(instance, 0, excb, sentcb);
    }
 
    template <class T>
    class CallbackNC_TopicManagerInternal_getReplicaNode :
        public Callback_TopicManagerInternal_getReplicaNode_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 ::IceStormElection::NodePrx&);
 
        CallbackNC_TopicManagerInternal_getReplicaNode(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
        {
            ::IceStorm::TopicManagerInternalPrx proxy =
                ::IceStorm::TopicManagerInternalPrx::uncheckedCast(result->getProxy());
            ::IceStormElection::NodePrx ret;
            try
            {
                ret = proxy->end_getReplicaNode(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_TopicManagerInternal_getReplicaNodePtr
    newCallback_TopicManagerInternal_getReplicaNode(
        const IceUtil::Handle<T>& instance,
        void (T::*cb)(const ::IceStormElection::NodePrx&),
        void (T::*excb)(const ::Ice::Exception&),
        void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicManagerInternal_getReplicaNode<T>(instance, cb, excb, sentcb);
    }
 
    template <class T>
    Callback_TopicManagerInternal_getReplicaNodePtr
    newCallback_TopicManagerInternal_getReplicaNode(
        T* instance,
        void (T::*cb)(const ::IceStormElection::NodePrx&),
        void (T::*excb)(const ::Ice::Exception&),
        void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicManagerInternal_getReplicaNode<T>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    class Callback_TopicManagerInternal_getReplicaNode :
        public Callback_TopicManagerInternal_getReplicaNode_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 ::IceStormElection::NodePrx&, const CT&);
 
        Callback_TopicManagerInternal_getReplicaNode(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
        {
            ::IceStorm::TopicManagerInternalPrx proxy =
                ::IceStorm::TopicManagerInternalPrx::uncheckedCast(result->getProxy());
            ::IceStormElection::NodePrx ret;
            try
            {
                ret = proxy->end_getReplicaNode(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_TopicManagerInternal_getReplicaNodePtr
    newCallback_TopicManagerInternal_getReplicaNode(
        const IceUtil::Handle<T>& instance,
        void (T::*cb)(const ::IceStormElection::NodePrx&, const CT&),
        void (T::*excb)(const ::Ice::Exception&, const CT&),
        void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicManagerInternal_getReplicaNode<T, CT>(instance, cb, excb, sentcb);
    }
 
    template <class T, typename CT>
    Callback_TopicManagerInternal_getReplicaNodePtr
    newCallback_TopicManagerInternal_getReplicaNode(
        T* instance,
        void (T::*cb)(const ::IceStormElection::NodePrx&, const CT&),
        void (T::*excb)(const ::Ice::Exception&, const CT&),
        void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicManagerInternal_getReplicaNode<T, CT>(instance, cb, excb, sentcb);
    }
 
} // namespace IceStorm
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif