Election.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 `Election.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __IceStorm_Election_h__
#define __IceStorm_Election_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 <Ice/Identity.h>
#include <Ice/BuiltinSequences.h>
#include <IceStorm/SubscriberRecord.h>
#include <IceStorm/LLURecord.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 IceStormElection
{
 
    class ReplicaObserver;
    class ReplicaObserverPrx;
    class TopicManagerSync;
    class TopicManagerSyncPrx;
    class Node;
    class NodePrx;
 
}
 
namespace IceStormElection
{
 
    struct TopicContent
    {
        ::Ice::Identity id;
        ::IceStorm::SubscriberRecordSeq records;
 
        std::tuple<const ::Ice::Identity&, const ::IceStorm::SubscriberRecordSeq&> ice_tuple() const
        {
            return std::tie(id, records);
        }
    };
 
    using TopicContentSeq = ::std::vector<::IceStormElection::TopicContent>;
 
    class ObserverInconsistencyException : public ::Ice::UserExceptionHelper<ObserverInconsistencyException, ::Ice::UserException>
    {
    public:
 
        virtual ~ObserverInconsistencyException();
 
        ObserverInconsistencyException(const ObserverInconsistencyException&) = default;
 
        ObserverInconsistencyException() = default;
 
        ObserverInconsistencyException(const ::std::string& iceP_reason) :
            reason(::std::move(iceP_reason))
        {
        }
 
        std::tuple<const ::std::string&> ice_tuple() const
        {
            return std::tie(reason);
        }
 
        static const ::std::string& ice_staticId();
 
        ::std::string reason;
    };
 
    static ObserverInconsistencyException _iceS_ObserverInconsistencyException_init;
 
    enum class NodeState : unsigned char
    {
        NodeStateInactive,
        NodeStateElection,
        NodeStateReorganization,
        NodeStateNormal
    };
 
    struct NodeInfo
    {
        int id;
        ::std::shared_ptr<::IceStormElection::NodePrx> n;
 
        std::tuple<const int&, const ::std::shared_ptr<::IceStormElection::NodePrx>&> ice_tuple() const
        {
            return std::tie(id, n);
        }
    };
 
    using NodeInfoSeq = ::std::vector<::IceStormElection::NodeInfo>;
 
    struct GroupInfo
    {
        int id;
        ::IceStormElection::LogUpdate llu;
 
        std::tuple<const int&, const ::IceStormElection::LogUpdate&> ice_tuple() const
        {
            return std::tie(id, llu);
        }
    };
 
    using GroupInfoSeq = ::std::vector<::IceStormElection::GroupInfo>;
 
    struct QueryInfo
    {
        int id;
        int coord;
        ::std::string group;
        ::std::shared_ptr<::Ice::ObjectPrx> replica;
        ::IceStormElection::NodeState state;
        ::IceStormElection::GroupInfoSeq up;
        int max;
 
        std::tuple<const int&, const int&, const ::std::string&, const ::std::shared_ptr<::Ice::ObjectPrx>&, const ::IceStormElection::NodeState&, const ::IceStormElection::GroupInfoSeq&, const int&> ice_tuple() const
        {
            return std::tie(id, coord, group, replica, state, up, max);
        }
    };
 
    using Ice::operator<;
    using Ice::operator<=;
    using Ice::operator>;
    using Ice::operator>=;
    using Ice::operator==;
    using Ice::operator!=;
 
}
 
namespace IceStormElection
{
 
    class ReplicaObserver : public virtual ::Ice::Object
    {
    public:
 
        using ProxyType = ReplicaObserverPrx;
 
        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 init(::IceStormElection::LogUpdate, ::IceStormElection::TopicContentSeq, const ::Ice::Current&) = 0;
        bool _iceD_init(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void createTopic(::IceStormElection::LogUpdate, ::std::string, const ::Ice::Current&) = 0;
        bool _iceD_createTopic(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void destroyTopic(::IceStormElection::LogUpdate, ::std::string, const ::Ice::Current&) = 0;
        bool _iceD_destroyTopic(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void addSubscriber(::IceStormElection::LogUpdate, ::std::string, ::IceStorm::SubscriberRecord, const ::Ice::Current&) = 0;
        bool _iceD_addSubscriber(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void removeSubscriber(::IceStormElection::LogUpdate, ::std::string, ::Ice::IdentitySeq, const ::Ice::Current&) = 0;
        bool _iceD_removeSubscriber(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
    };
 
    class TopicManagerSync : public virtual ::Ice::Object
    {
    public:
 
        using ProxyType = TopicManagerSyncPrx;
 
        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();
 
        struct GetContentResult
        {
            ::IceStormElection::LogUpdate llu;
            ::IceStormElection::TopicContentSeq content;
        };
 
        virtual void getContent(::IceStormElection::LogUpdate&, ::IceStormElection::TopicContentSeq&, const ::Ice::Current&) = 0;
        bool _iceD_getContent(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
    };
 
    class Node : public virtual ::Ice::Object
    {
    public:
 
        using ProxyType = NodePrx;
 
        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 invitation(int, ::std::string, const ::Ice::Current&) = 0;
        bool _iceD_invitation(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void ready(int, ::std::string, ::std::shared_ptr<::Ice::ObjectPrx>, int, long long int, const ::Ice::Current&) = 0;
        bool _iceD_ready(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void accept(int, ::std::string, ::Ice::IntSeq, ::std::shared_ptr<::Ice::ObjectPrx>, ::IceStormElection::LogUpdate, int, const ::Ice::Current&) = 0;
        bool _iceD_accept(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual bool areYouCoordinator(const ::Ice::Current&) const = 0;
        bool _iceD_areYouCoordinator(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual bool areYouThere(::std::string, int, const ::Ice::Current&) const = 0;
        bool _iceD_areYouThere(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> sync(const ::Ice::Current&) const = 0;
        bool _iceD_sync(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual ::IceStormElection::NodeInfoSeq nodes(const ::Ice::Current&) const = 0;
        bool _iceD_nodes(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual ::IceStormElection::QueryInfo query(const ::Ice::Current&) const = 0;
        bool _iceD_query(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
    };
 
}
 
namespace IceStormElection
{
 
    class ReplicaObserverPrx : public virtual ::Ice::Proxy<ReplicaObserverPrx, ::Ice::ObjectPrx>
    {
    public:
 
        void init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::ReplicaObserverPrx::_iceI_init, iceP_llu, iceP_content, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto initAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::ReplicaObserverPrx::_iceI_init, iceP_llu, iceP_content, context);
        }
 
        ::std::function<void()>
        initAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content,
                  ::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, &IceStormElection::ReplicaObserverPrx::_iceI_init, iceP_llu, iceP_content, context);
        }
 
        void _iceI_init(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&, const ::Ice::Context&);
 
        void createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::ReplicaObserverPrx::_iceI_createTopic, iceP_llu, iceP_name, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto createTopicAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::ReplicaObserverPrx::_iceI_createTopic, iceP_llu, iceP_name, context);
        }
 
        ::std::function<void()>
        createTopicAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name,
                         ::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, &IceStormElection::ReplicaObserverPrx::_iceI_createTopic, iceP_llu, iceP_name, context);
        }
 
        void _iceI_createTopic(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::Context&);
 
        void destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::ReplicaObserverPrx::_iceI_destroyTopic, iceP_llu, iceP_name, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto destroyTopicAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::ReplicaObserverPrx::_iceI_destroyTopic, iceP_llu, iceP_name, context);
        }
 
        ::std::function<void()>
        destroyTopicAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name,
                          ::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, &IceStormElection::ReplicaObserverPrx::_iceI_destroyTopic, iceP_llu, iceP_name, context);
        }
 
        void _iceI_destroyTopic(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::Context&);
 
        void addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::ReplicaObserverPrx::_iceI_addSubscriber, iceP_llu, iceP_topic, iceP_record, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto addSubscriberAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::ReplicaObserverPrx::_iceI_addSubscriber, iceP_llu, iceP_topic, iceP_record, context);
        }
 
        ::std::function<void()>
        addSubscriberAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record,
                           ::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, &IceStormElection::ReplicaObserverPrx::_iceI_addSubscriber, iceP_llu, iceP_topic, iceP_record, context);
        }
 
        void _iceI_addSubscriber(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::IceStormElection::LogUpdate&, const ::std::string&, const ::IceStorm::SubscriberRecord&, const ::Ice::Context&);
 
        void removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::ReplicaObserverPrx::_iceI_removeSubscriber, iceP_llu, iceP_topic, iceP_subscribers, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto removeSubscriberAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::ReplicaObserverPrx::_iceI_removeSubscriber, iceP_llu, iceP_topic, iceP_subscribers, context);
        }
 
        ::std::function<void()>
        removeSubscriberAsync(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers,
                              ::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, &IceStormElection::ReplicaObserverPrx::_iceI_removeSubscriber, iceP_llu, iceP_topic, iceP_subscribers, context);
        }
 
        void _iceI_removeSubscriber(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::IdentitySeq&, const ::Ice::Context&);
 
        static const ::std::string& ice_staticId();
 
    protected:
 
        ReplicaObserverPrx() = default;
        friend ::std::shared_ptr<ReplicaObserverPrx> IceInternal::createProxy<ReplicaObserverPrx>();
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
    };
 
    class TopicManagerSyncPrx : public virtual ::Ice::Proxy<TopicManagerSyncPrx, ::Ice::ObjectPrx>
    {
    public:
 
        void getContent(::IceStormElection::LogUpdate& iceP_llu, ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            auto result = _makePromiseOutgoing<::IceStormElection::TopicManagerSync::GetContentResult>(true, this, &IceStormElection::TopicManagerSyncPrx::_iceI_getContent, context).get();
            iceP_llu = ::std::move(result.llu);
            iceP_content = ::std::move(result.content);
        }
 
        template<template<typename> class P = ::std::promise>
        auto getContentAsync(const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<::IceStormElection::TopicManagerSync::GetContentResult>>().get_future())
        {
            return _makePromiseOutgoing<::IceStormElection::TopicManagerSync::GetContentResult, P>(false, this, &IceStormElection::TopicManagerSyncPrx::_iceI_getContent, context);
        }
 
        ::std::function<void()>
        getContentAsync(::std::function<void(::IceStormElection::LogUpdate, ::IceStormElection::TopicContentSeq)> response,
                        ::std::function<void(::std::exception_ptr)> ex = nullptr,
                        ::std::function<void(bool)> sent = nullptr,
                        const ::Ice::Context& context = Ice::noExplicitContext)
        {
            auto responseCb = [response](::IceStormElection::TopicManagerSync::GetContentResult && result)
            {
                response(::std::move(result.llu), ::std::move(result.content));
            };
            return _makeLamdaOutgoing<::IceStormElection::TopicManagerSync::GetContentResult>(responseCb, ex, sent, this, &IceStormElection::TopicManagerSyncPrx::_iceI_getContent, context);
        }
 
        void _iceI_getContent(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceStormElection::TopicManagerSync::GetContentResult>>&, const ::Ice::Context&);
 
        static const ::std::string& ice_staticId();
 
    protected:
 
        TopicManagerSyncPrx() = default;
        friend ::std::shared_ptr<TopicManagerSyncPrx> IceInternal::createProxy<TopicManagerSyncPrx>();
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
    };
 
    class NodePrx : public virtual ::Ice::Proxy<NodePrx, ::Ice::ObjectPrx>
    {
    public:
 
        void invitation(int iceP_j, const ::std::string& iceP_gn, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::NodePrx::_iceI_invitation, iceP_j, iceP_gn, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto invitationAsync(int iceP_j, const ::std::string& iceP_gn, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::NodePrx::_iceI_invitation, iceP_j, iceP_gn, context);
        }
 
        ::std::function<void()>
        invitationAsync(int iceP_j, const ::std::string& iceP_gn,
                        ::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, &IceStormElection::NodePrx::_iceI_invitation, iceP_j, iceP_gn, context);
        }
 
        void _iceI_invitation(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, int, const ::std::string&, const ::Ice::Context&);
 
        void ready(int iceP_j, const ::std::string& iceP_gn, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_coordinator, int iceP_max, long long int iceP_generation, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::NodePrx::_iceI_ready, iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto readyAsync(int iceP_j, const ::std::string& iceP_gn, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_coordinator, int iceP_max, long long int iceP_generation, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::NodePrx::_iceI_ready, iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context);
        }
 
        ::std::function<void()>
        readyAsync(int iceP_j, const ::std::string& iceP_gn, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_coordinator, int iceP_max, long long int iceP_generation,
                   ::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, &IceStormElection::NodePrx::_iceI_ready, iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context);
        }
 
        void _iceI_ready(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, int, const ::std::string&, const ::std::shared_ptr<::Ice::ObjectPrx>&, int, long long int, const ::Ice::Context&);
 
        void accept(int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, int iceP_max, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            _makePromiseOutgoing<void>(true, this, &IceStormElection::NodePrx::_iceI_accept, iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto acceptAsync(int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, int iceP_max, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
        {
            return _makePromiseOutgoing<void, P>(false, this, &IceStormElection::NodePrx::_iceI_accept, iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context);
        }
 
        ::std::function<void()>
        acceptAsync(int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::std::shared_ptr<::Ice::ObjectPrx>& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, int iceP_max,
                    ::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, &IceStormElection::NodePrx::_iceI_accept, iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context);
        }
 
        void _iceI_accept(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, int, const ::std::string&, const ::Ice::IntSeq&, const ::std::shared_ptr<::Ice::ObjectPrx>&, const ::IceStormElection::LogUpdate&, int, const ::Ice::Context&);
 
        bool areYouCoordinator(const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<bool>(true, this, &IceStormElection::NodePrx::_iceI_areYouCoordinator, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto areYouCoordinatorAsync(const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<bool>>().get_future())
        {
            return _makePromiseOutgoing<bool, P>(false, this, &IceStormElection::NodePrx::_iceI_areYouCoordinator, context);
        }
 
        ::std::function<void()>
        areYouCoordinatorAsync(::std::function<void(bool)> response,
                               ::std::function<void(::std::exception_ptr)> ex = nullptr,
                               ::std::function<void(bool)> sent = nullptr,
                               const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makeLamdaOutgoing<bool>(response, ex, sent, this, &IceStormElection::NodePrx::_iceI_areYouCoordinator, context);
        }
 
        void _iceI_areYouCoordinator(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::Ice::Context&);
 
        bool areYouThere(const ::std::string& iceP_gn, int iceP_j, const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<bool>(true, this, &IceStormElection::NodePrx::_iceI_areYouThere, iceP_gn, iceP_j, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto areYouThereAsync(const ::std::string& iceP_gn, int iceP_j, const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<bool>>().get_future())
        {
            return _makePromiseOutgoing<bool, P>(false, this, &IceStormElection::NodePrx::_iceI_areYouThere, iceP_gn, iceP_j, context);
        }
 
        ::std::function<void()>
        areYouThereAsync(const ::std::string& iceP_gn, int iceP_j,
                         ::std::function<void(bool)> response,
                         ::std::function<void(::std::exception_ptr)> ex = nullptr,
                         ::std::function<void(bool)> sent = nullptr,
                         const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makeLamdaOutgoing<bool>(response, ex, sent, this, &IceStormElection::NodePrx::_iceI_areYouThere, iceP_gn, iceP_j, context);
        }
 
        void _iceI_areYouThere(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<bool>>&, const ::std::string&, int, const ::Ice::Context&);
 
        ::std::shared_ptr<::Ice::ObjectPrx> sync(const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<::std::shared_ptr<::Ice::ObjectPrx>>(true, this, &IceStormElection::NodePrx::_iceI_sync, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto syncAsync(const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<::std::shared_ptr<::Ice::ObjectPrx>>>().get_future())
        {
            return _makePromiseOutgoing<::std::shared_ptr<::Ice::ObjectPrx>, P>(false, this, &IceStormElection::NodePrx::_iceI_sync, context);
        }
 
        ::std::function<void()>
        syncAsync(::std::function<void(::std::shared_ptr<::Ice::ObjectPrx>)> 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<::Ice::ObjectPrx>>(response, ex, sent, this, &IceStormElection::NodePrx::_iceI_sync, context);
        }
 
        void _iceI_sync(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>&, const ::Ice::Context&);
 
        ::IceStormElection::NodeInfoSeq nodes(const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<::IceStormElection::NodeInfoSeq>(true, this, &IceStormElection::NodePrx::_iceI_nodes, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto nodesAsync(const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<::IceStormElection::NodeInfoSeq>>().get_future())
        {
            return _makePromiseOutgoing<::IceStormElection::NodeInfoSeq, P>(false, this, &IceStormElection::NodePrx::_iceI_nodes, context);
        }
 
        ::std::function<void()>
        nodesAsync(::std::function<void(::IceStormElection::NodeInfoSeq)> response,
                   ::std::function<void(::std::exception_ptr)> ex = nullptr,
                   ::std::function<void(bool)> sent = nullptr,
                   const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makeLamdaOutgoing<::IceStormElection::NodeInfoSeq>(response, ex, sent, this, &IceStormElection::NodePrx::_iceI_nodes, context);
        }
 
        void _iceI_nodes(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceStormElection::NodeInfoSeq>>&, const ::Ice::Context&);
 
        ::IceStormElection::QueryInfo query(const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makePromiseOutgoing<::IceStormElection::QueryInfo>(true, this, &IceStormElection::NodePrx::_iceI_query, context).get();
        }
 
        template<template<typename> class P = ::std::promise>
        auto queryAsync(const ::Ice::Context& context = Ice::noExplicitContext)
        -> decltype(::std::declval<P<::IceStormElection::QueryInfo>>().get_future())
        {
            return _makePromiseOutgoing<::IceStormElection::QueryInfo, P>(false, this, &IceStormElection::NodePrx::_iceI_query, context);
        }
 
        ::std::function<void()>
        queryAsync(::std::function<void(::IceStormElection::QueryInfo)> response,
                   ::std::function<void(::std::exception_ptr)> ex = nullptr,
                   ::std::function<void(bool)> sent = nullptr,
                   const ::Ice::Context& context = Ice::noExplicitContext)
        {
            return _makeLamdaOutgoing<::IceStormElection::QueryInfo>(response, ex, sent, this, &IceStormElection::NodePrx::_iceI_query, context);
        }
 
        void _iceI_query(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceStormElection::QueryInfo>>&, const ::Ice::Context&);
 
        static const ::std::string& ice_staticId();
 
    protected:
 
        NodePrx() = default;
        friend ::std::shared_ptr<NodePrx> IceInternal::createProxy<NodePrx>();
 
        virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
    };
 
}
 
namespace Ice
{
 
    template<>
    struct StreamableTraits<::IceStormElection::TopicContent>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 3;
        static const bool fixedLength = false;
    };
 
    template<typename S>
    struct StreamReader<::IceStormElection::TopicContent, S>
    {
        static void read(S* istr, ::IceStormElection::TopicContent& v)
        {
            istr->readAll(v.id, v.records);
        }
    };
 
    template<typename S>
    struct StreamReader<::IceStormElection::ObserverInconsistencyException, S>
    {
        static void read(S* istr, ::IceStormElection::ObserverInconsistencyException& v)
        {
            istr->readAll(v.reason);
        }
    };
 
    template<>
    struct StreamableTraits< ::IceStormElection::NodeState>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryEnum;
        static const int minValue = 0;
        static const int maxValue = 3;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };
 
    template<>
    struct StreamableTraits<::IceStormElection::NodeInfo>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 6;
        static const bool fixedLength = false;
    };
 
    template<typename S>
    struct StreamReader<::IceStormElection::NodeInfo, S>
    {
        static void read(S* istr, ::IceStormElection::NodeInfo& v)
        {
            istr->readAll(v.id, v.n);
        }
    };
 
    template<>
    struct StreamableTraits<::IceStormElection::GroupInfo>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 20;
        static const bool fixedLength = true;
    };
 
    template<typename S>
    struct StreamReader<::IceStormElection::GroupInfo, S>
    {
        static void read(S* istr, ::IceStormElection::GroupInfo& v)
        {
            istr->readAll(v.id, v.llu);
        }
    };
 
    template<>
    struct StreamableTraits<::IceStormElection::QueryInfo>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 17;
        static const bool fixedLength = false;
    };
 
    template<typename S>
    struct StreamReader<::IceStormElection::QueryInfo, S>
    {
        static void read(S* istr, ::IceStormElection::QueryInfo& v)
        {
            istr->readAll(v.id, v.coord, v.group, v.replica, v.state, v.up, v.max);
        }
    };
 
}
 
namespace IceStormElection
{
 
    using ReplicaObserverPtr = ::std::shared_ptr<ReplicaObserver>;
    using ReplicaObserverPrxPtr = ::std::shared_ptr<ReplicaObserverPrx>;
 
    using TopicManagerSyncPtr = ::std::shared_ptr<TopicManagerSync>;
    using TopicManagerSyncPrxPtr = ::std::shared_ptr<TopicManagerSyncPrx>;
 
    using NodePtr = ::std::shared_ptr<Node>;
    using NodePrxPtr = ::std::shared_ptr<NodePrx>;
 
}
 
#else // C++98 mapping
 
namespace IceProxy::IceStormElection
{
 
    class ReplicaObserver;
    void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::ReplicaObserver>&);
    ::IceProxy::Ice::Object* upCast(::IceProxy::IceStormElection::ReplicaObserver*);
 
    class TopicManagerSync;
    void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::TopicManagerSync>&);
    ::IceProxy::Ice::Object* upCast(::IceProxy::IceStormElection::TopicManagerSync*);
 
    class Node;
    void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::Node>&);
    ::IceProxy::Ice::Object* upCast(::IceProxy::IceStormElection::Node*);
 
}
 
 
 
namespace IceStormElection
{
 
    class ReplicaObserver;
    ::Ice::Object* upCast(::IceStormElection::ReplicaObserver*);
    typedef ::IceInternal::Handle< ::IceStormElection::ReplicaObserver> ReplicaObserverPtr;
    typedef ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::ReplicaObserver> ReplicaObserverPrx;
    typedef ReplicaObserverPrx ReplicaObserverPrxPtr;
    void _icePatchObjectPtr(ReplicaObserverPtr&, const ::Ice::ObjectPtr&);
 
    class TopicManagerSync;
    ::Ice::Object* upCast(::IceStormElection::TopicManagerSync*);
    typedef ::IceInternal::Handle< ::IceStormElection::TopicManagerSync> TopicManagerSyncPtr;
    typedef ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::TopicManagerSync> TopicManagerSyncPrx;
    typedef TopicManagerSyncPrx TopicManagerSyncPrxPtr;
    void _icePatchObjectPtr(TopicManagerSyncPtr&, const ::Ice::ObjectPtr&);
 
    class Node;
    ::Ice::Object* upCast(::IceStormElection::Node*);
    typedef ::IceInternal::Handle< ::IceStormElection::Node> NodePtr;
    typedef ::IceInternal::ProxyHandle< ::IceProxy::IceStormElection::Node> NodePrx;
    typedef NodePrx NodePrxPtr;
    void _icePatchObjectPtr(NodePtr&, const ::Ice::ObjectPtr&);
 
}
 
namespace IceStormElection
{
 
    struct TopicContent
    {
        ::Ice::Identity id;
        ::IceStorm::SubscriberRecordSeq records;
    };
 
    typedef ::std::vector< ::IceStormElection::TopicContent> TopicContentSeq;
 
    class ObserverInconsistencyException : public ::Ice::UserException
    {
    public:
 
        ObserverInconsistencyException() {}
        explicit ObserverInconsistencyException(const ::std::string&);
        virtual ~ObserverInconsistencyException() throw();
 
        virtual ::std::string ice_id() const;
        virtual ObserverInconsistencyException* ice_clone() const;
        virtual void ice_throw() const;
 
        ::std::string reason;
 
    protected:
 
        virtual void _writeImpl(::Ice::OutputStream*) const;
        virtual void _readImpl(::Ice::InputStream*);
    };
 
    static ObserverInconsistencyException _iceS_ObserverInconsistencyException_init;
 
    enum NodeState
    {
        NodeStateInactive,
        NodeStateElection,
        NodeStateReorganization,
        NodeStateNormal
    };
 
    struct NodeInfo
    {
        ::Ice::Int id;
        ::IceStormElection::NodePrx n;
    };
 
    typedef ::std::vector< ::IceStormElection::NodeInfo> NodeInfoSeq;
 
    struct GroupInfo
    {
        ::Ice::Int id;
        ::IceStormElection::LogUpdate llu;
 
        bool operator==(const GroupInfo& rhs_) const
        {
            if (this == &rhs_)
            {
                return true;
            }
            if (id != rhs_.id)
            {
                return false;
            }
            if (llu != rhs_.llu)
            {
                return false;
            }
            return true;
        }
 
        bool operator<(const GroupInfo& rhs_) const
        {
            if (this == &rhs_)
            {
                return false;
            }
            if (id < rhs_.id)
            {
                return true;
            }
            else if (rhs_.id < id)
            {
                return false;
            }
            if (llu < rhs_.llu)
            {
                return true;
            }
            else if (rhs_.llu < llu)
            {
                return false;
            }
            return false;
        }
 
        bool operator!=(const GroupInfo& rhs_) const
        {
            return !operator==(rhs_);
        }
        bool operator<=(const GroupInfo& rhs_) const
        {
            return operator<(rhs_) || operator==(rhs_);
        }
        bool operator>(const GroupInfo& rhs_) const
        {
            return !operator<(rhs_) && !operator==(rhs_);
        }
        bool operator>=(const GroupInfo& rhs_) const
        {
            return !operator<(rhs_);
        }
    };
 
    typedef ::std::vector< ::IceStormElection::GroupInfo> GroupInfoSeq;
 
    struct QueryInfo
    {
        ::Ice::Int id;
        ::Ice::Int coord;
        ::std::string group;
        ::Ice::ObjectPrx replica;
        ::IceStormElection::NodeState state;
        ::IceStormElection::GroupInfoSeq up;
        ::Ice::Int max;
    };
 
}
 
namespace IceStormElection
{
 
    class Callback_ReplicaObserver_init_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_ReplicaObserver_init_Base> Callback_ReplicaObserver_initPtr;
 
    class Callback_ReplicaObserver_createTopic_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_ReplicaObserver_createTopic_Base> Callback_ReplicaObserver_createTopicPtr;
 
    class Callback_ReplicaObserver_destroyTopic_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_ReplicaObserver_destroyTopic_Base> Callback_ReplicaObserver_destroyTopicPtr;
 
    class Callback_ReplicaObserver_addSubscriber_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_ReplicaObserver_addSubscriber_Base> Callback_ReplicaObserver_addSubscriberPtr;
 
    class Callback_ReplicaObserver_removeSubscriber_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_ReplicaObserver_removeSubscriber_Base> Callback_ReplicaObserver_removeSubscriberPtr;
 
    class Callback_TopicManagerSync_getContent_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_TopicManagerSync_getContent_Base> Callback_TopicManagerSync_getContentPtr;
 
    class Callback_Node_invitation_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_invitation_Base> Callback_Node_invitationPtr;
 
    class Callback_Node_ready_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_ready_Base> Callback_Node_readyPtr;
 
    class Callback_Node_accept_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_accept_Base> Callback_Node_acceptPtr;
 
    class Callback_Node_areYouCoordinator_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_areYouCoordinator_Base> Callback_Node_areYouCoordinatorPtr;
 
    class Callback_Node_areYouThere_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_areYouThere_Base> Callback_Node_areYouTherePtr;
 
    class Callback_Node_sync_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_sync_Base> Callback_Node_syncPtr;
 
    class Callback_Node_nodes_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_nodes_Base> Callback_Node_nodesPtr;
 
    class Callback_Node_query_Base : public virtual ::IceInternal::CallbackBase { };
    typedef ::IceUtil::Handle< Callback_Node_query_Base> Callback_Node_queryPtr;
 
}
 
namespace IceProxy::IceStormElection
{
 
    class ReplicaObserver : public virtual ::Ice::Proxy<ReplicaObserver, ::IceProxy::Ice::Object>
    {
    public:
 
        void init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_init(_iceI_begin_init(iceP_llu, iceP_content, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_init(iceP_llu, iceP_content, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_init(iceP_llu, iceP_content, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_init(iceP_llu, iceP_content, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::IceStormElection::Callback_ReplicaObserver_initPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_init(iceP_llu, iceP_content, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_init(const ::IceStormElection::LogUpdate& iceP_llu, const ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context, const ::IceStormElection::Callback_ReplicaObserver_initPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_init(iceP_llu, iceP_content, context, del, cookie);
        }
 
        void end_init(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_init(const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        void createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_createTopic(_iceI_begin_createTopic(iceP_llu, iceP_name, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_createTopic(iceP_llu, iceP_name, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_createTopic(iceP_llu, iceP_name, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_createTopic(iceP_llu, iceP_name, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::IceStormElection::Callback_ReplicaObserver_createTopicPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_createTopic(iceP_llu, iceP_name, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_createTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceStormElection::Callback_ReplicaObserver_createTopicPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_createTopic(iceP_llu, iceP_name, context, del, cookie);
        }
 
        void end_createTopic(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_createTopic(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        void destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_destroyTopic(_iceI_begin_destroyTopic(iceP_llu, iceP_name, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_destroyTopic(iceP_llu, iceP_name, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_destroyTopic(iceP_llu, iceP_name, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_destroyTopic(iceP_llu, iceP_name, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::IceStormElection::Callback_ReplicaObserver_destroyTopicPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_destroyTopic(iceP_llu, iceP_name, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_destroyTopic(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_name, const ::Ice::Context& context, const ::IceStormElection::Callback_ReplicaObserver_destroyTopicPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_destroyTopic(iceP_llu, iceP_name, context, del, cookie);
        }
 
        void end_destroyTopic(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_destroyTopic(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        void addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_addSubscriber(_iceI_begin_addSubscriber(iceP_llu, iceP_topic, iceP_record, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_addSubscriber(iceP_llu, iceP_topic, iceP_record, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_addSubscriber(iceP_llu, iceP_topic, iceP_record, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_addSubscriber(iceP_llu, iceP_topic, iceP_record, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::IceStormElection::Callback_ReplicaObserver_addSubscriberPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_addSubscriber(iceP_llu, iceP_topic, iceP_record, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_addSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::IceStorm::SubscriberRecord& iceP_record, const ::Ice::Context& context, const ::IceStormElection::Callback_ReplicaObserver_addSubscriberPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_addSubscriber(iceP_llu, iceP_topic, iceP_record, context, del, cookie);
        }
 
        void end_addSubscriber(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_addSubscriber(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::IceStorm::SubscriberRecord&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        void removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_removeSubscriber(_iceI_begin_removeSubscriber(iceP_llu, iceP_topic, iceP_subscribers, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_removeSubscriber(iceP_llu, iceP_topic, iceP_subscribers, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_removeSubscriber(iceP_llu, iceP_topic, iceP_subscribers, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_removeSubscriber(iceP_llu, iceP_topic, iceP_subscribers, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::IceStormElection::Callback_ReplicaObserver_removeSubscriberPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_removeSubscriber(iceP_llu, iceP_topic, iceP_subscribers, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_removeSubscriber(const ::IceStormElection::LogUpdate& iceP_llu, const ::std::string& iceP_topic, const ::Ice::IdentitySeq& iceP_subscribers, const ::Ice::Context& context, const ::IceStormElection::Callback_ReplicaObserver_removeSubscriberPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_removeSubscriber(iceP_llu, iceP_topic, iceP_subscribers, context, del, cookie);
        }
 
        void end_removeSubscriber(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_removeSubscriber(const ::IceStormElection::LogUpdate&, const ::std::string&, 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 TopicManagerSync : public virtual ::Ice::Proxy<TopicManagerSync, ::IceProxy::Ice::Object>
    {
    public:
 
        void getContent(::IceStormElection::LogUpdate& iceP_llu, ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_getContent(iceP_llu, iceP_content, _iceI_begin_getContent(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_getContent(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_getContent(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_getContent(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getContent(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_getContent(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getContent(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_getContent(const ::IceStormElection::Callback_TopicManagerSync_getContentPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getContent(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_getContent(const ::Ice::Context& context, const ::IceStormElection::Callback_TopicManagerSync_getContentPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_getContent(context, del, cookie);
        }
 
        void end_getContent(::IceStormElection::LogUpdate& iceP_llu, ::IceStormElection::TopicContentSeq& iceP_content, const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_getContent(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 Node : public virtual ::Ice::Proxy<Node, ::IceProxy::Ice::Object>
    {
    public:
 
        void invitation(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_invitation(_iceI_begin_invitation(iceP_j, iceP_gn, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_invitation(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_invitation(iceP_j, iceP_gn, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_invitation(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_invitation(iceP_j, iceP_gn, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_invitation(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_invitation(iceP_j, iceP_gn, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_invitation(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::IceStormElection::Callback_Node_invitationPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_invitation(iceP_j, iceP_gn, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_invitation(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::Context& context, const ::IceStormElection::Callback_Node_invitationPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_invitation(iceP_j, iceP_gn, context, del, cookie);
        }
 
        void end_invitation(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_invitation(::Ice::Int, const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        void ready(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::ObjectPrx& iceP_coordinator, ::Ice::Int iceP_max, ::Ice::Long iceP_generation, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_ready(_iceI_begin_ready(iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_ready(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::ObjectPrx& iceP_coordinator, ::Ice::Int iceP_max, ::Ice::Long iceP_generation, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_ready(iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_ready(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::ObjectPrx& iceP_coordinator, ::Ice::Int iceP_max, ::Ice::Long iceP_generation, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_ready(iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_ready(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::ObjectPrx& iceP_coordinator, ::Ice::Int iceP_max, ::Ice::Long iceP_generation, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_ready(iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_ready(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::ObjectPrx& iceP_coordinator, ::Ice::Int iceP_max, ::Ice::Long iceP_generation, const ::IceStormElection::Callback_Node_readyPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_ready(iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_ready(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::ObjectPrx& iceP_coordinator, ::Ice::Int iceP_max, ::Ice::Long iceP_generation, const ::Ice::Context& context, const ::IceStormElection::Callback_Node_readyPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_ready(iceP_j, iceP_gn, iceP_coordinator, iceP_max, iceP_generation, context, del, cookie);
        }
 
        void end_ready(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_ready(::Ice::Int, const ::std::string&, const ::Ice::ObjectPrx&, ::Ice::Int, ::Ice::Long, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        void accept(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::Ice::ObjectPrx& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, ::Ice::Int iceP_max, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            end_accept(_iceI_begin_accept(iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_accept(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::Ice::ObjectPrx& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, ::Ice::Int iceP_max, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_accept(iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_accept(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::Ice::ObjectPrx& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, ::Ice::Int iceP_max, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_accept(iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_accept(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::Ice::ObjectPrx& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, ::Ice::Int iceP_max, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_accept(iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_accept(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::Ice::ObjectPrx& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, ::Ice::Int iceP_max, const ::IceStormElection::Callback_Node_acceptPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_accept(iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_accept(::Ice::Int iceP_j, const ::std::string& iceP_gn, const ::Ice::IntSeq& iceP_forwardedInvites, const ::Ice::ObjectPrx& iceP_observer, const ::IceStormElection::LogUpdate& iceP_llu, ::Ice::Int iceP_max, const ::Ice::Context& context, const ::IceStormElection::Callback_Node_acceptPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_accept(iceP_j, iceP_gn, iceP_forwardedInvites, iceP_observer, iceP_llu, iceP_max, context, del, cookie);
        }
 
        void end_accept(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_accept(::Ice::Int, const ::std::string&, const ::Ice::IntSeq&, const ::Ice::ObjectPrx&, const ::IceStormElection::LogUpdate&, ::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        bool areYouCoordinator(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_areYouCoordinator(_iceI_begin_areYouCoordinator(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_areYouCoordinator(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_areYouCoordinator(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_areYouCoordinator(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouCoordinator(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_areYouCoordinator(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouCoordinator(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_areYouCoordinator(const ::IceStormElection::Callback_Node_areYouCoordinatorPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouCoordinator(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_areYouCoordinator(const ::Ice::Context& context, const ::IceStormElection::Callback_Node_areYouCoordinatorPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouCoordinator(context, del, cookie);
        }
 
        bool end_areYouCoordinator(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_areYouCoordinator(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        bool areYouThere(const ::std::string& iceP_gn, ::Ice::Int iceP_j, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_areYouThere(_iceI_begin_areYouThere(iceP_gn, iceP_j, context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_areYouThere(const ::std::string& iceP_gn, ::Ice::Int iceP_j, const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_areYouThere(iceP_gn, iceP_j, context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_areYouThere(const ::std::string& iceP_gn, ::Ice::Int iceP_j, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouThere(iceP_gn, iceP_j, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_areYouThere(const ::std::string& iceP_gn, ::Ice::Int iceP_j, const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouThere(iceP_gn, iceP_j, context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_areYouThere(const ::std::string& iceP_gn, ::Ice::Int iceP_j, const ::IceStormElection::Callback_Node_areYouTherePtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouThere(iceP_gn, iceP_j, ::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_areYouThere(const ::std::string& iceP_gn, ::Ice::Int iceP_j, const ::Ice::Context& context, const ::IceStormElection::Callback_Node_areYouTherePtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_areYouThere(iceP_gn, iceP_j, context, del, cookie);
        }
 
        bool end_areYouThere(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_areYouThere(const ::std::string&, ::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        ::Ice::ObjectPrx sync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_sync(_iceI_begin_sync(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_sync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_sync(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_sync(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_sync(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_sync(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_sync(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_sync(const ::IceStormElection::Callback_Node_syncPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_sync(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_sync(const ::Ice::Context& context, const ::IceStormElection::Callback_Node_syncPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_sync(context, del, cookie);
        }
 
        ::Ice::ObjectPrx end_sync(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_sync(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        ::IceStormElection::NodeInfoSeq nodes(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_nodes(_iceI_begin_nodes(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_nodes(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_nodes(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_nodes(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_nodes(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_nodes(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_nodes(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_nodes(const ::IceStormElection::Callback_Node_nodesPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_nodes(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_nodes(const ::Ice::Context& context, const ::IceStormElection::Callback_Node_nodesPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_nodes(context, del, cookie);
        }
 
        ::IceStormElection::NodeInfoSeq end_nodes(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_nodes(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
    public:
 
        ::IceStormElection::QueryInfo query(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return end_query(_iceI_begin_query(context, ::IceInternal::dummyCallback, 0, true));
        }
 
        ::Ice::AsyncResultPtr begin_query(const ::Ice::Context& context = ::Ice::noExplicitContext)
        {
            return _iceI_begin_query(context, ::IceInternal::dummyCallback, 0);
        }
 
        ::Ice::AsyncResultPtr begin_query(const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_query(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_query(const ::Ice::Context& context, const ::Ice::CallbackPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_query(context, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_query(const ::IceStormElection::Callback_Node_queryPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_query(::Ice::noExplicitContext, del, cookie);
        }
 
        ::Ice::AsyncResultPtr begin_query(const ::Ice::Context& context, const ::IceStormElection::Callback_Node_queryPtr& del, const ::Ice::LocalObjectPtr& cookie = 0)
        {
            return _iceI_begin_query(context, del, cookie);
        }
 
        ::IceStormElection::QueryInfo end_query(const ::Ice::AsyncResultPtr&);
 
    private:
 
        ::Ice::AsyncResultPtr _iceI_begin_query(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 IceStormElection
{
 
    class ReplicaObserver : public virtual ::Ice::Object
    {
    public:
 
        typedef ReplicaObserverPrx ProxyType;
        typedef ReplicaObserverPtr PointerType;
 
        virtual ~ReplicaObserver();
 
        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 init(const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_init(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void createTopic(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_createTopic(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void destroyTopic(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_destroyTopic(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void addSubscriber(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::IceStorm::SubscriberRecord&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_addSubscriber(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void removeSubscriber(const ::IceStormElection::LogUpdate&, const ::std::string&, const ::Ice::IdentitySeq&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_removeSubscriber(::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 ReplicaObserver& lhs, const ReplicaObserver& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
    }
 
    inline bool operator<(const ReplicaObserver& lhs, const ReplicaObserver& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
    }
 
    class TopicManagerSync : public virtual ::Ice::Object
    {
    public:
 
        typedef TopicManagerSyncPrx ProxyType;
        typedef TopicManagerSyncPtr PointerType;
 
        virtual ~TopicManagerSync();
 
        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 getContent(::IceStormElection::LogUpdate&, ::IceStormElection::TopicContentSeq&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_getContent(::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 TopicManagerSync& lhs, const TopicManagerSync& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
    }
 
    inline bool operator<(const TopicManagerSync& lhs, const TopicManagerSync& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
    }
 
    class Node : public virtual ::Ice::Object
    {
    public:
 
        typedef NodePrx ProxyType;
        typedef NodePtr PointerType;
 
        virtual ~Node();
 
        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 invitation(::Ice::Int, const ::std::string&, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_invitation(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void ready(::Ice::Int, const ::std::string&, const ::Ice::ObjectPrx&, ::Ice::Int, ::Ice::Long, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_ready(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual void accept(::Ice::Int, const ::std::string&, const ::Ice::IntSeq&, const ::Ice::ObjectPrx&, const ::IceStormElection::LogUpdate&, ::Ice::Int, const ::Ice::Current& = ::Ice::emptyCurrent) = 0;
        bool _iceD_accept(::IceInternal::Incoming&, const ::Ice::Current&);
 
        virtual bool areYouCoordinator(const ::Ice::Current& = ::Ice::emptyCurrent) const = 0;
        bool _iceD_areYouCoordinator(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual bool areYouThere(const ::std::string&, ::Ice::Int, const ::Ice::Current& = ::Ice::emptyCurrent) const = 0;
        bool _iceD_areYouThere(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual ::Ice::ObjectPrx sync(const ::Ice::Current& = ::Ice::emptyCurrent) const = 0;
        bool _iceD_sync(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual ::IceStormElection::NodeInfoSeq nodes(const ::Ice::Current& = ::Ice::emptyCurrent) const = 0;
        bool _iceD_nodes(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
        virtual ::IceStormElection::QueryInfo query(const ::Ice::Current& = ::Ice::emptyCurrent) const = 0;
        bool _iceD_query(::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 Node& lhs, const Node& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
    }
 
    inline bool operator<(const Node& lhs, const Node& rhs)
    {
        return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
    }
 
}
 
namespace Ice
{
 
    template<>
    struct StreamableTraits< ::IceStormElection::TopicContent>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 3;
        static const bool fixedLength = false;
    };
 
    template<typename S>
    struct StreamWriter< ::IceStormElection::TopicContent, S>
    {
        static void write(S* ostr, const ::IceStormElection::TopicContent& v)
        {
            ostr->write(v.id);
            ostr->write(v.records);
        }
    };
 
    template<typename S>
    struct StreamReader< ::IceStormElection::TopicContent, S>
    {
        static void read(S* istr, ::IceStormElection::TopicContent& v)
        {
            istr->read(v.id);
            istr->read(v.records);
        }
    };
 
    template<>
    struct StreamableTraits< ::IceStormElection::ObserverInconsistencyException>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryUserException;
    };
 
    template<typename S>
    struct StreamWriter< ::IceStormElection::ObserverInconsistencyException, S>
    {
        static void write(S* ostr, const ::IceStormElection::ObserverInconsistencyException& v)
        {
            ostr->write(v.reason);
        }
    };
 
    template<typename S>
    struct StreamReader< ::IceStormElection::ObserverInconsistencyException, S>
    {
        static void read(S* istr, ::IceStormElection::ObserverInconsistencyException& v)
        {
            istr->read(v.reason);
        }
    };
 
    template<>
    struct StreamableTraits< ::IceStormElection::NodeState>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryEnum;
        static const int minValue = 0;
        static const int maxValue = 3;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };
 
    template<>
    struct StreamableTraits< ::IceStormElection::NodeInfo>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 6;
        static const bool fixedLength = false;
    };
 
    template<typename S>
    struct StreamWriter< ::IceStormElection::NodeInfo, S>
    {
        static void write(S* ostr, const ::IceStormElection::NodeInfo& v)
        {
            ostr->write(v.id);
            ostr->write(v.n);
        }
    };
 
    template<typename S>
    struct StreamReader< ::IceStormElection::NodeInfo, S>
    {
        static void read(S* istr, ::IceStormElection::NodeInfo& v)
        {
            istr->read(v.id);
            istr->read(v.n);
        }
    };
 
    template<>
    struct StreamableTraits< ::IceStormElection::GroupInfo>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 20;
        static const bool fixedLength = true;
    };
 
    template<typename S>
    struct StreamWriter< ::IceStormElection::GroupInfo, S>
    {
        static void write(S* ostr, const ::IceStormElection::GroupInfo& v)
        {
            ostr->write(v.id);
            ostr->write(v.llu);
        }
    };
 
    template<typename S>
    struct StreamReader< ::IceStormElection::GroupInfo, S>
    {
        static void read(S* istr, ::IceStormElection::GroupInfo& v)
        {
            istr->read(v.id);
            istr->read(v.llu);
        }
    };
 
    template<>
    struct StreamableTraits< ::IceStormElection::QueryInfo>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryStruct;
        static const int minWireSize = 17;
        static const bool fixedLength = false;
    };
 
    template<typename S>
    struct StreamWriter< ::IceStormElection::QueryInfo, S>
    {
        static void write(S* ostr, const ::IceStormElection::QueryInfo& v)
        {
            ostr->write(v.id);
            ostr->write(v.coord);
            ostr->write(v.group);
            ostr->write(v.replica);
            ostr->write(v.state);
            ostr->write(v.up);
            ostr->write(v.max);
        }
    };
 
    template<typename S>
    struct StreamReader< ::IceStormElection::QueryInfo, S>
    {
        static void read(S* istr, ::IceStormElection::QueryInfo& v)
        {
            istr->read(v.id);
            istr->read(v.coord);
            istr->read(v.group);
            istr->read(v.replica);
            istr->read(v.state);
            istr->read(v.up);
            istr->read(v.max);
        }
    };
 
}
 
namespace IceStormElection
{
 
    template<class T>
    class CallbackNC_ReplicaObserver_init : public Callback_ReplicaObserver_init_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_ReplicaObserver_init(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_init(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_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_init<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_init<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_init<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_init<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_ReplicaObserver_init : public Callback_ReplicaObserver_init_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_ReplicaObserver_init(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_init(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_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(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_ReplicaObserver_init<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_init<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(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_ReplicaObserver_init<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_initPtr
    newCallback_ReplicaObserver_init(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_init<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_ReplicaObserver_createTopic : public Callback_ReplicaObserver_createTopic_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_ReplicaObserver_createTopic(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_createTopic(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_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_createTopic<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_createTopic<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_createTopic<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_createTopic<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_ReplicaObserver_createTopic : public Callback_ReplicaObserver_createTopic_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_ReplicaObserver_createTopic(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_createTopic(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_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(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_ReplicaObserver_createTopic<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_createTopic<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(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_ReplicaObserver_createTopic<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_createTopicPtr
    newCallback_ReplicaObserver_createTopic(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_createTopic<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_ReplicaObserver_destroyTopic : public Callback_ReplicaObserver_destroyTopic_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_ReplicaObserver_destroyTopic(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_destroyTopic(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_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_destroyTopic<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_destroyTopic<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_destroyTopic<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_destroyTopic<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_ReplicaObserver_destroyTopic : public Callback_ReplicaObserver_destroyTopic_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_ReplicaObserver_destroyTopic(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_destroyTopic(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_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(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_ReplicaObserver_destroyTopic<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_destroyTopic<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(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_ReplicaObserver_destroyTopic<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_destroyTopicPtr
    newCallback_ReplicaObserver_destroyTopic(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_destroyTopic<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_ReplicaObserver_addSubscriber : public Callback_ReplicaObserver_addSubscriber_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_ReplicaObserver_addSubscriber(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_addSubscriber(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_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_addSubscriber<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_addSubscriber<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_addSubscriber<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_addSubscriber<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_ReplicaObserver_addSubscriber : public Callback_ReplicaObserver_addSubscriber_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_ReplicaObserver_addSubscriber(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_addSubscriber(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_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(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_ReplicaObserver_addSubscriber<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_addSubscriber<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(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_ReplicaObserver_addSubscriber<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_addSubscriberPtr
    newCallback_ReplicaObserver_addSubscriber(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_addSubscriber<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_ReplicaObserver_removeSubscriber : public Callback_ReplicaObserver_removeSubscriber_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_ReplicaObserver_removeSubscriber(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_removeSubscriber(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_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_removeSubscriber<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_removeSubscriber<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_removeSubscriber<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_ReplicaObserver_removeSubscriber<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_ReplicaObserver_removeSubscriber : public Callback_ReplicaObserver_removeSubscriber_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_ReplicaObserver_removeSubscriber(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
        {
            ::IceStormElection::ReplicaObserverPrx proxy = ::IceStormElection::ReplicaObserverPrx::uncheckedCast(result->getProxy());
            try
            {
                proxy->end_removeSubscriber(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_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(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_ReplicaObserver_removeSubscriber<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_removeSubscriber<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(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_ReplicaObserver_removeSubscriber<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_ReplicaObserver_removeSubscriberPtr
    newCallback_ReplicaObserver_removeSubscriber(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_ReplicaObserver_removeSubscriber<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_TopicManagerSync_getContent : public Callback_TopicManagerSync_getContent_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::LogUpdate&, const ::IceStormElection::TopicContentSeq&);
 
        CallbackNC_TopicManagerSync_getContent(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
        {
            ::IceStormElection::TopicManagerSyncPrx proxy = ::IceStormElection::TopicManagerSyncPrx::uncheckedCast(result->getProxy());
            ::IceStormElection::LogUpdate iceP_llu;
            ::IceStormElection::TopicContentSeq iceP_content;
            try
            {
                proxy->end_getContent(iceP_llu, iceP_content, result);
            }
            catch (const ::Ice::Exception& ex)
            {
                ::IceInternal::CallbackNC<T>::exception(result, ex);
                return;
            }
            if (_response)
            {
                (::IceInternal::CallbackNC<T>::_callback.get()->*_response)(iceP_llu, iceP_content);
            }
        }
 
    private:
 
        Response _response;
    };
 
    template<class T> Callback_TopicManagerSync_getContentPtr
    newCallback_TopicManagerSync_getContent(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicManagerSync_getContent<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_TopicManagerSync_getContentPtr
    newCallback_TopicManagerSync_getContent(T* instance, void (T::*cb)(const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_TopicManagerSync_getContent<T>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_TopicManagerSync_getContent : public Callback_TopicManagerSync_getContent_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::LogUpdate&, const ::IceStormElection::TopicContentSeq&, const CT&);
 
        Callback_TopicManagerSync_getContent(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
        {
            ::IceStormElection::TopicManagerSyncPrx proxy = ::IceStormElection::TopicManagerSyncPrx::uncheckedCast(result->getProxy());
            ::IceStormElection::LogUpdate iceP_llu;
            ::IceStormElection::TopicContentSeq iceP_content;
            try
            {
                proxy->end_getContent(iceP_llu, iceP_content, result);
            }
            catch (const ::Ice::Exception& ex)
            {
                ::IceInternal::Callback<T, CT>::exception(result, ex);
                return;
            }
            if (_response)
            {
                (::IceInternal::Callback<T, CT>::_callback.get()->*_response)(iceP_llu, iceP_content, CT::dynamicCast(result->getCookie()));
            }
        }
 
    private:
 
        Response _response;
    };
 
    template<class T, typename CT> Callback_TopicManagerSync_getContentPtr
    newCallback_TopicManagerSync_getContent(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicManagerSync_getContent<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_TopicManagerSync_getContentPtr
    newCallback_TopicManagerSync_getContent(T* instance, void (T::*cb)(const ::IceStormElection::LogUpdate&, const ::IceStormElection::TopicContentSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_TopicManagerSync_getContent<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_invitation : public Callback_Node_invitation_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_Node_invitation(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template<class T> Callback_Node_invitationPtr
    newCallback_Node_invitation(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_invitation<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_invitationPtr
    newCallback_Node_invitation(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_invitation<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_Node_invitationPtr
    newCallback_Node_invitation(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_invitation<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_invitationPtr
    newCallback_Node_invitation(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_invitation<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_invitation : public Callback_Node_invitation_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_Node_invitation(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template<class T, typename CT> Callback_Node_invitationPtr
    newCallback_Node_invitation(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_Node_invitation<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_invitationPtr
    newCallback_Node_invitation(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_invitation<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_invitationPtr
    newCallback_Node_invitation(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_Node_invitation<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_invitationPtr
    newCallback_Node_invitation(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_invitation<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_ready : public Callback_Node_ready_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_Node_ready(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template<class T> Callback_Node_readyPtr
    newCallback_Node_ready(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_ready<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_readyPtr
    newCallback_Node_ready(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_ready<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_Node_readyPtr
    newCallback_Node_ready(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_ready<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_readyPtr
    newCallback_Node_ready(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_ready<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_ready : public Callback_Node_ready_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_Node_ready(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template<class T, typename CT> Callback_Node_readyPtr
    newCallback_Node_ready(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_Node_ready<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_readyPtr
    newCallback_Node_ready(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_ready<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_readyPtr
    newCallback_Node_ready(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_Node_ready<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_readyPtr
    newCallback_Node_ready(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_ready<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_accept : public Callback_Node_accept_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_Node_accept(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template<class T> Callback_Node_acceptPtr
    newCallback_Node_accept(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_accept<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_acceptPtr
    newCallback_Node_accept(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_accept<T>(instance, 0, excb, sentcb);
    }
 
    template<class T> Callback_Node_acceptPtr
    newCallback_Node_accept(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_accept<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_acceptPtr
    newCallback_Node_accept(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_accept<T>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_accept : public Callback_Node_accept_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_Node_accept(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
            : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
        {
        }
    };
 
    template<class T, typename CT> Callback_Node_acceptPtr
    newCallback_Node_accept(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_Node_accept<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_acceptPtr
    newCallback_Node_accept(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_accept<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_acceptPtr
    newCallback_Node_accept(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_Node_accept<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_acceptPtr
    newCallback_Node_accept(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_accept<T, CT>(instance, 0, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_areYouCoordinator : public Callback_Node_areYouCoordinator_Base, public ::IceInternal::TwowayCallbackNC<T>
    {
    public:
 
        typedef IceUtil::Handle<T> TPtr;
 
        typedef void (T::*Exception)(const ::Ice::Exception&);
        typedef void (T::*Sent)(bool);
        typedef void (T::*Response)(bool);
 
        CallbackNC_Node_areYouCoordinator(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            bool ret;
            try
            {
                ret = proxy->end_areYouCoordinator(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_Node_areYouCoordinatorPtr
    newCallback_Node_areYouCoordinator(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_areYouCoordinator<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_areYouCoordinatorPtr
    newCallback_Node_areYouCoordinator(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_areYouCoordinator<T>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_areYouCoordinator : public Callback_Node_areYouCoordinator_Base, public ::IceInternal::TwowayCallback<T, CT>
    {
    public:
 
        typedef IceUtil::Handle<T> TPtr;
 
        typedef void (T::*Exception)(const ::Ice::Exception&, const CT&);
        typedef void (T::*Sent)(bool, const CT&);
        typedef void (T::*Response)(bool, const CT&);
 
        Callback_Node_areYouCoordinator(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            bool ret;
            try
            {
                ret = proxy->end_areYouCoordinator(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_Node_areYouCoordinatorPtr
    newCallback_Node_areYouCoordinator(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_areYouCoordinator<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_areYouCoordinatorPtr
    newCallback_Node_areYouCoordinator(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_areYouCoordinator<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_areYouThere : public Callback_Node_areYouThere_Base, public ::IceInternal::TwowayCallbackNC<T>
    {
    public:
 
        typedef IceUtil::Handle<T> TPtr;
 
        typedef void (T::*Exception)(const ::Ice::Exception&);
        typedef void (T::*Sent)(bool);
        typedef void (T::*Response)(bool);
 
        CallbackNC_Node_areYouThere(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            bool ret;
            try
            {
                ret = proxy->end_areYouThere(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_Node_areYouTherePtr
    newCallback_Node_areYouThere(const IceUtil::Handle<T>& instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_areYouThere<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_areYouTherePtr
    newCallback_Node_areYouThere(T* instance, void (T::*cb)(bool), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_areYouThere<T>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_areYouThere : public Callback_Node_areYouThere_Base, public ::IceInternal::TwowayCallback<T, CT>
    {
    public:
 
        typedef IceUtil::Handle<T> TPtr;
 
        typedef void (T::*Exception)(const ::Ice::Exception&, const CT&);
        typedef void (T::*Sent)(bool, const CT&);
        typedef void (T::*Response)(bool, const CT&);
 
        Callback_Node_areYouThere(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            bool ret;
            try
            {
                ret = proxy->end_areYouThere(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_Node_areYouTherePtr
    newCallback_Node_areYouThere(const IceUtil::Handle<T>& instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_areYouThere<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_areYouTherePtr
    newCallback_Node_areYouThere(T* instance, void (T::*cb)(bool, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_areYouThere<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_sync : public Callback_Node_sync_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 ::Ice::ObjectPrx&);
 
        CallbackNC_Node_sync(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            ::Ice::ObjectPrx ret;
            try
            {
                ret = proxy->end_sync(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_Node_syncPtr
    newCallback_Node_sync(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_sync<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_syncPtr
    newCallback_Node_sync(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_sync<T>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_sync : public Callback_Node_sync_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 ::Ice::ObjectPrx&, const CT&);
 
        Callback_Node_sync(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            ::Ice::ObjectPrx ret;
            try
            {
                ret = proxy->end_sync(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_Node_syncPtr
    newCallback_Node_sync(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::ObjectPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_sync<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_syncPtr
    newCallback_Node_sync(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_sync<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_nodes : public Callback_Node_nodes_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::NodeInfoSeq&);
 
        CallbackNC_Node_nodes(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            ::IceStormElection::NodeInfoSeq ret;
            try
            {
                ret = proxy->end_nodes(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_Node_nodesPtr
    newCallback_Node_nodes(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceStormElection::NodeInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_nodes<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_nodesPtr
    newCallback_Node_nodes(T* instance, void (T::*cb)(const ::IceStormElection::NodeInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_nodes<T>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_nodes : public Callback_Node_nodes_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::NodeInfoSeq&, const CT&);
 
        Callback_Node_nodes(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            ::IceStormElection::NodeInfoSeq ret;
            try
            {
                ret = proxy->end_nodes(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_Node_nodesPtr
    newCallback_Node_nodes(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceStormElection::NodeInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_nodes<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_nodesPtr
    newCallback_Node_nodes(T* instance, void (T::*cb)(const ::IceStormElection::NodeInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_nodes<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T>
    class CallbackNC_Node_query : public Callback_Node_query_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::QueryInfo&);
 
        CallbackNC_Node_query(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            ::IceStormElection::QueryInfo ret;
            try
            {
                ret = proxy->end_query(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_Node_queryPtr
    newCallback_Node_query(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceStormElection::QueryInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_query<T>(instance, cb, excb, sentcb);
    }
 
    template<class T> Callback_Node_queryPtr
    newCallback_Node_query(T* instance, void (T::*cb)(const ::IceStormElection::QueryInfo&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
    {
        return new CallbackNC_Node_query<T>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT>
    class Callback_Node_query : public Callback_Node_query_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::QueryInfo&, const CT&);
 
        Callback_Node_query(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
        {
            ::IceStormElection::NodePrx proxy = ::IceStormElection::NodePrx::uncheckedCast(result->getProxy());
            ::IceStormElection::QueryInfo ret;
            try
            {
                ret = proxy->end_query(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_Node_queryPtr
    newCallback_Node_query(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::IceStormElection::QueryInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_query<T, CT>(instance, cb, excb, sentcb);
    }
 
    template<class T, typename CT> Callback_Node_queryPtr
    newCallback_Node_query(T* instance, void (T::*cb)(const ::IceStormElection::QueryInfo&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
    {
        return new Callback_Node_query<T, CT>(instance, cb, excb, sentcb);
    }
 
}
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif