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 <IceUtil/PushDisableWarnings.h>
#include <Ice/ProxyF.h>
#include <Ice/ObjectF.h>
#include <Ice/ValueF.h>
#include <Ice/Exception.h>
#include <Ice/LocalObject.h>
#include <Ice/StreamHelpers.h>
#include <Ice/Comparable.h>
#include <Ice/Proxy.h>
#include <Ice/Object.h>
#include <Ice/GCObject.h>
#include <Ice/Value.h>
#include <Ice/Incoming.h>
#include <Ice/FactoryTableInit.h>
#include <IceUtil/ScopedArray.h>
#include <Ice/Optional.h>
#include <Ice/ExceptionHelpers.h>
#include <IceStorm/IceStorm.h>
#include <IceStorm/Election.h>
#include <Ice/Current.h>
#include <IceUtil/UndefSysMacros.h>
#include <deque>
 
#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
{
 
    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
{
 
    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
{
 
    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 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 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>;
 
}
 
#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 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
{
 
    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
{
 
    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 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 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 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 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);
    }
 
}
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif