IceStorm.h

Go to the documentation of this file.

//
// Copyright (c) ZeroC, Inc. All rights reserved.
//
//
// Ice version 3.7.10
//
// <auto-generated>
//
// Generated from file `IceStorm.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __IceStorm_IceStorm_h__
#define __IceStorm_IceStorm_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/SliceChecksumDict.h>
#include <IceStorm/Metrics.h>
#include <IceUtil/UndefSysMacros.h>
#include <IceStorm/Config.h>
 
#ifndef ICE_IGNORE_VERSION
#   if ICE_INT_VERSION / 100 != 307
#       error Ice version mismatch!
#   endif
#   if ICE_INT_VERSION % 100 >= 50
#       error Beta header file detected
#   endif
#   if ICE_INT_VERSION % 100 < 10
#       error Ice patch level mismatch!
#   endif
#endif
 
#ifndef ICESTORM_API
#   if defined(ICE_STATIC_LIBS)
#       define ICESTORM_API 
#   elif defined(ICESTORM_API_EXPORTS)
#       define ICESTORM_API ICE_DECLSPEC_EXPORT
#   else
#       define ICESTORM_API ICE_DECLSPEC_IMPORT
#   endif
#endif
 
#ifdef ICE_CPP11_MAPPING // C++11 mapping
 
namespace IceStorm
{
 
class Topic;
class TopicPrx;
class TopicManager;
class TopicManagerPrx;
class Finder;
class FinderPrx;
 
}
 
namespace IceStorm
{
 
struct LinkInfo
{
    ::std::shared_ptr<::IceStorm::TopicPrx> theTopic;
    ::std::string name;
    int cost;
 
    std::tuple<const ::std::shared_ptr<::IceStorm::TopicPrx>&, const ::std::string&, const int&> ice_tuple() const
    {
        return std::tie(theTopic, name, cost);
    }
};
 
using LinkInfoSeq = ::std::vector<LinkInfo>;
 
using QoS = ::std::map<::std::string, ::std::string>;
 
class ICE_CLASS(ICESTORM_API) LinkExists : public ::Ice::UserExceptionHelper<LinkExists, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~LinkExists();
 
    LinkExists(const LinkExists&) = default;
 
    LinkExists() = default;
 
    LinkExists(const ::std::string& name) :
        name(name)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(name);
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
    ::std::string name;
};
 
static LinkExists _iceS_LinkExists_init;
 
class ICE_CLASS(ICESTORM_API) NoSuchLink : public ::Ice::UserExceptionHelper<NoSuchLink, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~NoSuchLink();
 
    NoSuchLink(const NoSuchLink&) = default;
 
    NoSuchLink() = default;
 
    NoSuchLink(const ::std::string& name) :
        name(name)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(name);
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
    ::std::string name;
};
 
class ICE_CLASS(ICESTORM_API) AlreadySubscribed : public ::Ice::UserExceptionHelper<AlreadySubscribed, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~AlreadySubscribed();
 
    AlreadySubscribed(const AlreadySubscribed&) = default;
 
    AlreadySubscribed() = default;
 
    std::tuple<> ice_tuple() const
    {
        return std::tie();
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
};
 
class ICE_CLASS(ICESTORM_API) InvalidSubscriber : public ::Ice::UserExceptionHelper<InvalidSubscriber, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~InvalidSubscriber();
 
    InvalidSubscriber(const InvalidSubscriber&) = default;
 
    InvalidSubscriber() = default;
 
    InvalidSubscriber(const ::std::string& reason) :
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
    ::std::string reason;
};
 
class ICE_CLASS(ICESTORM_API) BadQoS : public ::Ice::UserExceptionHelper<BadQoS, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~BadQoS();
 
    BadQoS(const BadQoS&) = default;
 
    BadQoS() = default;
 
    BadQoS(const ::std::string& reason) :
        reason(reason)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(reason);
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
    ::std::string reason;
};
 
using TopicDict = ::std::map<::std::string, ::std::shared_ptr<TopicPrx>>;
 
class ICE_CLASS(ICESTORM_API) TopicExists : public ::Ice::UserExceptionHelper<TopicExists, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~TopicExists();
 
    TopicExists(const TopicExists&) = default;
 
    TopicExists() = default;
 
    TopicExists(const ::std::string& name) :
        name(name)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(name);
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
    ::std::string name;
};
 
class ICE_CLASS(ICESTORM_API) NoSuchTopic : public ::Ice::UserExceptionHelper<NoSuchTopic, ::Ice::UserException>
{
public:
 
    ICE_MEMBER(ICESTORM_API) virtual ~NoSuchTopic();
 
    NoSuchTopic(const NoSuchTopic&) = default;
 
    NoSuchTopic() = default;
 
    NoSuchTopic(const ::std::string& name) :
        name(name)
    {
    }
 
    std::tuple<const ::std::string&> ice_tuple() const
    {
        return std::tie(name);
    }
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
    ::std::string name;
};
 
using Ice::operator<;
using Ice::operator<=;
using Ice::operator>;
using Ice::operator>=;
using Ice::operator==;
using Ice::operator!=;
 
}
 
namespace IceStorm
{
 
class ICESTORM_API Topic : public virtual ::Ice::Object
{
public:
 
    using ProxyType = TopicPrx;
 
    virtual bool ice_isA(::std::string id, const ::Ice::Current& current) const override;
 
    virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& current) const override;
 
    virtual ::std::string ice_id(const ::Ice::Current& current) const override;
 
    static const ::std::string& ice_staticId();
 
    virtual ::std::string getName(const ::Ice::Current& current) const = 0;
    bool _iceD_getName(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::std::shared_ptr<::Ice::ObjectPrx> getPublisher(const ::Ice::Current& current) const = 0;
    bool _iceD_getPublisher(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::std::shared_ptr<::Ice::ObjectPrx> getNonReplicatedPublisher(const ::Ice::Current& current) const = 0;
    bool _iceD_getNonReplicatedPublisher(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::std::shared_ptr<::Ice::ObjectPrx> subscribeAndGetPublisher(QoS theQoS, ::std::shared_ptr<::Ice::ObjectPrx> subscriber, const ::Ice::Current& current) = 0;
    bool _iceD_subscribeAndGetPublisher(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void unsubscribe(::std::shared_ptr<::Ice::ObjectPrx> subscriber, const ::Ice::Current& current) = 0;
    bool _iceD_unsubscribe(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void link(::std::shared_ptr<TopicPrx> linkTo, int cost, const ::Ice::Current& current) = 0;
    bool _iceD_link(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void unlink(::std::shared_ptr<TopicPrx> linkTo, const ::Ice::Current& current) = 0;
    bool _iceD_unlink(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual LinkInfoSeq getLinkInfoSeq(const ::Ice::Current& current) const = 0;
    bool _iceD_getLinkInfoSeq(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::IdentitySeq getSubscribers(const ::Ice::Current& current) const = 0;
    bool _iceD_getSubscribers(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual void destroy(const ::Ice::Current& current) = 0;
    bool _iceD_destroy(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
};
 
class ICESTORM_API TopicManager : public virtual ::Ice::Object
{
public:
 
    using ProxyType = TopicManagerPrx;
 
    virtual bool ice_isA(::std::string id, const ::Ice::Current& current) const override;
 
    virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& current) const override;
 
    virtual ::std::string ice_id(const ::Ice::Current& current) const override;
 
    static const ::std::string& ice_staticId();
 
    virtual ::std::shared_ptr<TopicPrx> create(::std::string name, const ::Ice::Current& current) = 0;
    bool _iceD_create(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual ::std::shared_ptr<TopicPrx> retrieve(::std::string name, const ::Ice::Current& current) const = 0;
    bool _iceD_retrieve(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual TopicDict retrieveAll(const ::Ice::Current& current) const = 0;
    bool _iceD_retrieveAll(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Current& current) const = 0;
    bool _iceD_getSliceChecksums(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
};
 
class ICESTORM_API Finder : public virtual ::Ice::Object
{
public:
 
    using ProxyType = FinderPrx;
 
    virtual bool ice_isA(::std::string id, const ::Ice::Current& current) const override;
 
    virtual ::std::vector<::std::string> ice_ids(const ::Ice::Current& current) const override;
 
    virtual ::std::string ice_id(const ::Ice::Current& current) const override;
 
    static const ::std::string& ice_staticId();
 
    virtual ::std::shared_ptr<TopicManagerPrx> getTopicManager(const ::Ice::Current& current) = 0;
    bool _iceD_getTopicManager(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual bool _iceDispatch(::IceInternal::Incoming&, const ::Ice::Current&) override;
};
 
}
 
namespace IceStorm
{
 
class ICE_CLASS(ICESTORM_API) TopicPrx : public virtual ::Ice::Proxy<TopicPrx, ::Ice::ObjectPrx>
{
public:
 
    ::std::string getName(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::string>(true, this, &TopicPrx::_iceI_getName, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getNameAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::std::string>>().get_future())
    {
        return _makePromiseOutgoing<::std::string, P>(false, this, &TopicPrx::_iceI_getName, context);
    }
 
    ::std::function<void()>
    getNameAsync(::std::function<void(::std::string)> response,
                 ::std::function<void(::std::exception_ptr)> ex = nullptr,
                 ::std::function<void(bool)> sent = nullptr,
                 const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::std::string>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_getName, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getName(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::string>>&, const ::Ice::Context&);
 
    ::std::shared_ptr<::Ice::ObjectPrx> getPublisher(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::shared_ptr<::Ice::ObjectPrx>>(true, this, &TopicPrx::_iceI_getPublisher, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getPublisherAsync(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, &TopicPrx::_iceI_getPublisher, context);
    }
 
    ::std::function<void()>
    getPublisherAsync(::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>>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_getPublisher, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getPublisher(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>&, const ::Ice::Context&);
 
    ::std::shared_ptr<::Ice::ObjectPrx> getNonReplicatedPublisher(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::shared_ptr<::Ice::ObjectPrx>>(true, this, &TopicPrx::_iceI_getNonReplicatedPublisher, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getNonReplicatedPublisherAsync(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, &TopicPrx::_iceI_getNonReplicatedPublisher, context);
    }
 
    ::std::function<void()>
    getNonReplicatedPublisherAsync(::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>>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_getNonReplicatedPublisher, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getNonReplicatedPublisher(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>&, const ::Ice::Context&);
 
    ::std::shared_ptr<::Ice::ObjectPrx> subscribeAndGetPublisher(const QoS& theQoS, const ::std::shared_ptr<::Ice::ObjectPrx>& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::shared_ptr<::Ice::ObjectPrx>>(true, this, &TopicPrx::_iceI_subscribeAndGetPublisher, theQoS, subscriber, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto subscribeAndGetPublisherAsync(const QoS& theQoS, const ::std::shared_ptr<::Ice::ObjectPrx>& subscriber, 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, &TopicPrx::_iceI_subscribeAndGetPublisher, theQoS, subscriber, context);
    }
 
    ::std::function<void()>
    subscribeAndGetPublisherAsync(const QoS& theQoS, const ::std::shared_ptr<::Ice::ObjectPrx>& subscriber,
                                  ::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>>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_subscribeAndGetPublisher, theQoS, subscriber, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_subscribeAndGetPublisher(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::Ice::ObjectPrx>>>&, const QoS&, const ::std::shared_ptr<::Ice::ObjectPrx>&, const ::Ice::Context&);
 
    void unsubscribe(const ::std::shared_ptr<::Ice::ObjectPrx>& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        _makePromiseOutgoing<void>(true, this, &TopicPrx::_iceI_unsubscribe, subscriber, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto unsubscribeAsync(const ::std::shared_ptr<::Ice::ObjectPrx>& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
    {
        return _makePromiseOutgoing<void, P>(false, this, &TopicPrx::_iceI_unsubscribe, subscriber, context);
    }
 
    ::std::function<void()>
    unsubscribeAsync(const ::std::shared_ptr<::Ice::ObjectPrx>& subscriber,
                     ::std::function<void()> response,
                     ::std::function<void(::std::exception_ptr)> ex = nullptr,
                     ::std::function<void(bool)> sent = nullptr,
                     const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_unsubscribe, subscriber, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_unsubscribe(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::shared_ptr<::Ice::ObjectPrx>&, const ::Ice::Context&);
 
    void link(const ::std::shared_ptr<TopicPrx>& linkTo, int cost, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        _makePromiseOutgoing<void>(true, this, &TopicPrx::_iceI_link, linkTo, cost, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto linkAsync(const ::std::shared_ptr<TopicPrx>& linkTo, int cost, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
    {
        return _makePromiseOutgoing<void, P>(false, this, &TopicPrx::_iceI_link, linkTo, cost, context);
    }
 
    ::std::function<void()>
    linkAsync(const ::std::shared_ptr<TopicPrx>& linkTo, int cost,
              ::std::function<void()> response,
              ::std::function<void(::std::exception_ptr)> ex = nullptr,
              ::std::function<void(bool)> sent = nullptr,
              const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_link, linkTo, cost, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_link(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::shared_ptr<TopicPrx>&, int, const ::Ice::Context&);
 
    void unlink(const ::std::shared_ptr<TopicPrx>& linkTo, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        _makePromiseOutgoing<void>(true, this, &TopicPrx::_iceI_unlink, linkTo, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto unlinkAsync(const ::std::shared_ptr<TopicPrx>& linkTo, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
    {
        return _makePromiseOutgoing<void, P>(false, this, &TopicPrx::_iceI_unlink, linkTo, context);
    }
 
    ::std::function<void()>
    unlinkAsync(const ::std::shared_ptr<TopicPrx>& linkTo,
                ::std::function<void()> response,
                ::std::function<void(::std::exception_ptr)> ex = nullptr,
                ::std::function<void(bool)> sent = nullptr,
                const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_unlink, linkTo, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_unlink(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::std::shared_ptr<TopicPrx>&, const ::Ice::Context&);
 
    LinkInfoSeq getLinkInfoSeq(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::IceStorm::LinkInfoSeq>(true, this, &TopicPrx::_iceI_getLinkInfoSeq, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getLinkInfoSeqAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::IceStorm::LinkInfoSeq>>().get_future())
    {
        return _makePromiseOutgoing<::IceStorm::LinkInfoSeq, P>(false, this, &TopicPrx::_iceI_getLinkInfoSeq, context);
    }
 
    ::std::function<void()>
    getLinkInfoSeqAsync(::std::function<void(::IceStorm::LinkInfoSeq)> response,
                        ::std::function<void(::std::exception_ptr)> ex = nullptr,
                        ::std::function<void(bool)> sent = nullptr,
                        const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::IceStorm::LinkInfoSeq>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_getLinkInfoSeq, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getLinkInfoSeq(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceStorm::LinkInfoSeq>>&, const ::Ice::Context&);
 
    ::Ice::IdentitySeq getSubscribers(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::Ice::IdentitySeq>(true, this, &TopicPrx::_iceI_getSubscribers, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getSubscribersAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::Ice::IdentitySeq>>().get_future())
    {
        return _makePromiseOutgoing<::Ice::IdentitySeq, P>(false, this, &TopicPrx::_iceI_getSubscribers, context);
    }
 
    ::std::function<void()>
    getSubscribersAsync(::std::function<void(::Ice::IdentitySeq)> response,
                        ::std::function<void(::std::exception_ptr)> ex = nullptr,
                        ::std::function<void(bool)> sent = nullptr,
                        const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::Ice::IdentitySeq>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_getSubscribers, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getSubscribers(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::Ice::IdentitySeq>>&, const ::Ice::Context&);
 
    void destroy(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        _makePromiseOutgoing<void>(true, this, &TopicPrx::_iceI_destroy, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto destroyAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<void>>().get_future())
    {
        return _makePromiseOutgoing<void, P>(false, this, &TopicPrx::_iceI_destroy, context);
    }
 
    ::std::function<void()>
    destroyAsync(::std::function<void()> response,
                 ::std::function<void(::std::exception_ptr)> ex = nullptr,
                 ::std::function<void(bool)> sent = nullptr,
                 const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<void>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicPrx::_iceI_destroy, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_destroy(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<void>>&, const ::Ice::Context&);
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
protected:
 
    TopicPrx() = default;
    friend ::std::shared_ptr<TopicPrx> IceInternal::createProxy<TopicPrx>();
 
    ICE_MEMBER(ICESTORM_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
};
 
class ICE_CLASS(ICESTORM_API) TopicManagerPrx : public virtual ::Ice::Proxy<TopicManagerPrx, ::Ice::ObjectPrx>
{
public:
 
    ::std::shared_ptr<TopicPrx> create(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicPrx>>(true, this, &TopicManagerPrx::_iceI_create, name, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto createAsync(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::std::shared_ptr<::IceStorm::TopicPrx>>>().get_future())
    {
        return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicPrx>, P>(false, this, &TopicManagerPrx::_iceI_create, name, context);
    }
 
    ::std::function<void()>
    createAsync(const ::std::string& name,
                ::std::function<void(::std::shared_ptr<::IceStorm::TopicPrx>)> response,
                ::std::function<void(::std::exception_ptr)> ex = nullptr,
                ::std::function<void(bool)> sent = nullptr,
                const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::std::shared_ptr<::IceStorm::TopicPrx>>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicManagerPrx::_iceI_create, name, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_create(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStorm::TopicPrx>>>&, const ::std::string&, const ::Ice::Context&);
 
    ::std::shared_ptr<TopicPrx> retrieve(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicPrx>>(true, this, &TopicManagerPrx::_iceI_retrieve, name, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto retrieveAsync(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::std::shared_ptr<::IceStorm::TopicPrx>>>().get_future())
    {
        return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicPrx>, P>(false, this, &TopicManagerPrx::_iceI_retrieve, name, context);
    }
 
    ::std::function<void()>
    retrieveAsync(const ::std::string& name,
                  ::std::function<void(::std::shared_ptr<::IceStorm::TopicPrx>)> response,
                  ::std::function<void(::std::exception_ptr)> ex = nullptr,
                  ::std::function<void(bool)> sent = nullptr,
                  const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::std::shared_ptr<::IceStorm::TopicPrx>>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicManagerPrx::_iceI_retrieve, name, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_retrieve(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStorm::TopicPrx>>>&, const ::std::string&, const ::Ice::Context&);
 
    TopicDict retrieveAll(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::IceStorm::TopicDict>(true, this, &TopicManagerPrx::_iceI_retrieveAll, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto retrieveAllAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::IceStorm::TopicDict>>().get_future())
    {
        return _makePromiseOutgoing<::IceStorm::TopicDict, P>(false, this, &TopicManagerPrx::_iceI_retrieveAll, context);
    }
 
    ::std::function<void()>
    retrieveAllAsync(::std::function<void(::IceStorm::TopicDict)> response,
                     ::std::function<void(::std::exception_ptr)> ex = nullptr,
                     ::std::function<void(bool)> sent = nullptr,
                     const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::IceStorm::TopicDict>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicManagerPrx::_iceI_retrieveAll, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_retrieveAll(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::IceStorm::TopicDict>>&, const ::Ice::Context&);
 
    ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::Ice::SliceChecksumDict>(true, this, &TopicManagerPrx::_iceI_getSliceChecksums, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getSliceChecksumsAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::Ice::SliceChecksumDict>>().get_future())
    {
        return _makePromiseOutgoing<::Ice::SliceChecksumDict, P>(false, this, &TopicManagerPrx::_iceI_getSliceChecksums, context);
    }
 
    ::std::function<void()>
    getSliceChecksumsAsync(::std::function<void(::Ice::SliceChecksumDict)> response,
                           ::std::function<void(::std::exception_ptr)> ex = nullptr,
                           ::std::function<void(bool)> sent = nullptr,
                           const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::Ice::SliceChecksumDict>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::TopicManagerPrx::_iceI_getSliceChecksums, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getSliceChecksums(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::Ice::SliceChecksumDict>>&, const ::Ice::Context&);
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
protected:
 
    TopicManagerPrx() = default;
    friend ::std::shared_ptr<TopicManagerPrx> IceInternal::createProxy<TopicManagerPrx>();
 
    ICE_MEMBER(ICESTORM_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
};
 
class ICE_CLASS(ICESTORM_API) FinderPrx : public virtual ::Ice::Proxy<FinderPrx, ::Ice::ObjectPrx>
{
public:
 
    ::std::shared_ptr<TopicManagerPrx> getTopicManager(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicManagerPrx>>(true, this, &FinderPrx::_iceI_getTopicManager, context).get();
    }
 
    template<template<typename> class P = ::std::promise>
    auto getTopicManagerAsync(const ::Ice::Context& context = ::Ice::noExplicitContext)
        -> decltype(::std::declval<P<::std::shared_ptr<::IceStorm::TopicManagerPrx>>>().get_future())
    {
        return _makePromiseOutgoing<::std::shared_ptr<::IceStorm::TopicManagerPrx>, P>(false, this, &FinderPrx::_iceI_getTopicManager, context);
    }
 
    ::std::function<void()>
    getTopicManagerAsync(::std::function<void(::std::shared_ptr<::IceStorm::TopicManagerPrx>)> response,
                         ::std::function<void(::std::exception_ptr)> ex = nullptr,
                         ::std::function<void(bool)> sent = nullptr,
                         const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _makeLamdaOutgoing<::std::shared_ptr<::IceStorm::TopicManagerPrx>>(std::move(response), std::move(ex), std::move(sent), this, &IceStorm::FinderPrx::_iceI_getTopicManager, context);
    }
 
    ICE_MEMBER(ICESTORM_API) void _iceI_getTopicManager(const ::std::shared_ptr<::IceInternal::OutgoingAsyncT<::std::shared_ptr<::IceStorm::TopicManagerPrx>>>&, const ::Ice::Context&);
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
protected:
 
    FinderPrx() = default;
    friend ::std::shared_ptr<FinderPrx> IceInternal::createProxy<FinderPrx>();
 
    ICE_MEMBER(ICESTORM_API) virtual ::std::shared_ptr<::Ice::ObjectPrx> _newInstance() const override;
};
 
}
 
namespace Ice
{
 
template<>
struct StreamableTraits<::IceStorm::LinkInfo>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 7;
    static const bool fixedLength = false;
};
 
template<typename S>
struct StreamReader<::IceStorm::LinkInfo, S>
{
    static void read(S* istr, ::IceStorm::LinkInfo& v)
    {
        istr->readAll(v.theTopic, v.name, v.cost);
    }
};
 
template<typename S>
struct StreamReader<::IceStorm::LinkExists, S>
{
    static void read(S* istr, ::IceStorm::LinkExists& v)
    {
        istr->readAll(v.name);
    }
};
 
template<typename S>
struct StreamReader<::IceStorm::NoSuchLink, S>
{
    static void read(S* istr, ::IceStorm::NoSuchLink& v)
    {
        istr->readAll(v.name);
    }
};
 
template<typename S>
struct StreamReader<::IceStorm::InvalidSubscriber, S>
{
    static void read(S* istr, ::IceStorm::InvalidSubscriber& v)
    {
        istr->readAll(v.reason);
    }
};
 
template<typename S>
struct StreamReader<::IceStorm::BadQoS, S>
{
    static void read(S* istr, ::IceStorm::BadQoS& v)
    {
        istr->readAll(v.reason);
    }
};
 
template<typename S>
struct StreamReader<::IceStorm::TopicExists, S>
{
    static void read(S* istr, ::IceStorm::TopicExists& v)
    {
        istr->readAll(v.name);
    }
};
 
template<typename S>
struct StreamReader<::IceStorm::NoSuchTopic, S>
{
    static void read(S* istr, ::IceStorm::NoSuchTopic& v)
    {
        istr->readAll(v.name);
    }
};
 
}
 
namespace IceStorm
{
 
using TopicPtr = ::std::shared_ptr<Topic>;
using TopicPrxPtr = ::std::shared_ptr<TopicPrx>;
 
using TopicManagerPtr = ::std::shared_ptr<TopicManager>;
using TopicManagerPrxPtr = ::std::shared_ptr<TopicManagerPrx>;
 
using FinderPtr = ::std::shared_ptr<Finder>;
using FinderPrxPtr = ::std::shared_ptr<FinderPrx>;
 
}
 
#else // C++98 mapping
 
namespace IceProxy
{
 
namespace IceStorm
{
 
class Topic;
ICESTORM_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< Topic>&);
ICESTORM_API ::IceProxy::Ice::Object* upCast(Topic*);
 
class TopicManager;
ICESTORM_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< TopicManager>&);
ICESTORM_API ::IceProxy::Ice::Object* upCast(TopicManager*);
 
class Finder;
ICESTORM_API void _readProxy(::Ice::InputStream*, ::IceInternal::ProxyHandle< Finder>&);
ICESTORM_API ::IceProxy::Ice::Object* upCast(Finder*);
 
}
 
}
 
namespace IceStorm
{
 
class Topic;
ICESTORM_API ::Ice::Object* upCast(Topic*);
typedef ::IceInternal::Handle< Topic> TopicPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceStorm::Topic> TopicPrx;
typedef TopicPrx TopicPrxPtr;
ICESTORM_API void _icePatchObjectPtr(TopicPtr&, const ::Ice::ObjectPtr&);
 
class TopicManager;
ICESTORM_API ::Ice::Object* upCast(TopicManager*);
typedef ::IceInternal::Handle< TopicManager> TopicManagerPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceStorm::TopicManager> TopicManagerPrx;
typedef TopicManagerPrx TopicManagerPrxPtr;
ICESTORM_API void _icePatchObjectPtr(TopicManagerPtr&, const ::Ice::ObjectPtr&);
 
class Finder;
ICESTORM_API ::Ice::Object* upCast(Finder*);
typedef ::IceInternal::Handle< Finder> FinderPtr;
typedef ::IceInternal::ProxyHandle< ::IceProxy::IceStorm::Finder> FinderPrx;
typedef FinderPrx FinderPrxPtr;
ICESTORM_API void _icePatchObjectPtr(FinderPtr&, const ::Ice::ObjectPtr&);
 
}
 
namespace IceStorm
{
 
struct LinkInfo
{
    ::IceStorm::TopicPrx theTopic;
    ::std::string name;
    ::Ice::Int cost;
};
 
typedef ::std::vector<LinkInfo> LinkInfoSeq;
 
typedef ::std::map< ::std::string, ::std::string> QoS;
 
class ICESTORM_API LinkExists : public ::Ice::UserException
{
public:
 
    LinkExists() {}
    explicit LinkExists(const ::std::string& name);
 
#ifdef ICE_CPP11_COMPILER
    LinkExists(const LinkExists&) = default;
    virtual ~LinkExists();
#else
    virtual ~LinkExists() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual LinkExists* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string name;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
static LinkExists _iceS_LinkExists_init;
 
class ICESTORM_API NoSuchLink : public ::Ice::UserException
{
public:
 
    NoSuchLink() {}
    explicit NoSuchLink(const ::std::string& name);
 
#ifdef ICE_CPP11_COMPILER
    NoSuchLink(const NoSuchLink&) = default;
    virtual ~NoSuchLink();
#else
    virtual ~NoSuchLink() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual NoSuchLink* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string name;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
class ICESTORM_API AlreadySubscribed : public ::Ice::UserException
{
public:
 
    AlreadySubscribed() {}
 
#ifdef ICE_CPP11_COMPILER
    AlreadySubscribed(const AlreadySubscribed&) = default;
    virtual ~AlreadySubscribed();
#else
    virtual ~AlreadySubscribed() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual AlreadySubscribed* ice_clone() const;
    virtual void ice_throw() const;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
class ICESTORM_API InvalidSubscriber : public ::Ice::UserException
{
public:
 
    InvalidSubscriber() {}
    explicit InvalidSubscriber(const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    InvalidSubscriber(const InvalidSubscriber&) = default;
    virtual ~InvalidSubscriber();
#else
    virtual ~InvalidSubscriber() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual InvalidSubscriber* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
class ICESTORM_API BadQoS : public ::Ice::UserException
{
public:
 
    BadQoS() {}
    explicit BadQoS(const ::std::string& reason);
 
#ifdef ICE_CPP11_COMPILER
    BadQoS(const BadQoS&) = default;
    virtual ~BadQoS();
#else
    virtual ~BadQoS() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual BadQoS* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string reason;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
typedef ::std::map< ::std::string, TopicPrx> TopicDict;
 
class ICESTORM_API TopicExists : public ::Ice::UserException
{
public:
 
    TopicExists() {}
    explicit TopicExists(const ::std::string& name);
 
#ifdef ICE_CPP11_COMPILER
    TopicExists(const TopicExists&) = default;
    virtual ~TopicExists();
#else
    virtual ~TopicExists() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual TopicExists* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string name;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
class ICESTORM_API NoSuchTopic : public ::Ice::UserException
{
public:
 
    NoSuchTopic() {}
    explicit NoSuchTopic(const ::std::string& name);
 
#ifdef ICE_CPP11_COMPILER
    NoSuchTopic(const NoSuchTopic&) = default;
    virtual ~NoSuchTopic();
#else
    virtual ~NoSuchTopic() throw();
#endif
 
    virtual ::std::string ice_id() const;
    virtual NoSuchTopic* ice_clone() const;
    virtual void ice_throw() const;
 
    ::std::string name;
 
protected:
 
    virtual void _writeImpl(::Ice::OutputStream*) const;
    virtual void _readImpl(::Ice::InputStream*);
};
 
}
 
namespace IceStorm
{
 
class Callback_Topic_getName_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_getName_Base> Callback_Topic_getNamePtr;
 
class Callback_Topic_getPublisher_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_getPublisher_Base> Callback_Topic_getPublisherPtr;
 
class Callback_Topic_getNonReplicatedPublisher_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_getNonReplicatedPublisher_Base> Callback_Topic_getNonReplicatedPublisherPtr;
 
class Callback_Topic_subscribeAndGetPublisher_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_subscribeAndGetPublisher_Base> Callback_Topic_subscribeAndGetPublisherPtr;
 
class Callback_Topic_unsubscribe_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_unsubscribe_Base> Callback_Topic_unsubscribePtr;
 
class Callback_Topic_link_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_link_Base> Callback_Topic_linkPtr;
 
class Callback_Topic_unlink_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_unlink_Base> Callback_Topic_unlinkPtr;
 
class Callback_Topic_getLinkInfoSeq_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_getLinkInfoSeq_Base> Callback_Topic_getLinkInfoSeqPtr;
 
class Callback_Topic_getSubscribers_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_getSubscribers_Base> Callback_Topic_getSubscribersPtr;
 
class Callback_Topic_destroy_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Topic_destroy_Base> Callback_Topic_destroyPtr;
 
class Callback_TopicManager_create_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_TopicManager_create_Base> Callback_TopicManager_createPtr;
 
class Callback_TopicManager_retrieve_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_TopicManager_retrieve_Base> Callback_TopicManager_retrievePtr;
 
class Callback_TopicManager_retrieveAll_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_TopicManager_retrieveAll_Base> Callback_TopicManager_retrieveAllPtr;
 
class Callback_TopicManager_getSliceChecksums_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_TopicManager_getSliceChecksums_Base> Callback_TopicManager_getSliceChecksumsPtr;
 
class Callback_Finder_getTopicManager_Base : public virtual ::IceInternal::CallbackBase { };
typedef ::IceUtil::Handle< Callback_Finder_getTopicManager_Base> Callback_Finder_getTopicManagerPtr;
 
}
 
namespace IceProxy
{
 
namespace IceStorm
{
 
class ICE_CLASS(ICESTORM_API) Topic : public virtual ::Ice::Proxy<Topic, ::IceProxy::Ice::Object>
{
public:
 
    ICE_MEMBER(ICESTORM_API) ::std::string getName(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getName(_iceI_begin_getName(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getName(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getName(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getName(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getName(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getName(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getName(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getName(const ::IceStorm::Callback_Topic_getNamePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getName(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getName(const ::Ice::Context& context, const ::IceStorm::Callback_Topic_getNamePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getName(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::std::string end_getName(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getName(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::ObjectPrx getPublisher(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getPublisher(_iceI_begin_getPublisher(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getPublisher(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getPublisher(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getPublisher(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getPublisher(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getPublisher(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getPublisher(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getPublisher(const ::IceStorm::Callback_Topic_getPublisherPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getPublisher(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getPublisher(const ::Ice::Context& context, const ::IceStorm::Callback_Topic_getPublisherPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getPublisher(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::Ice::ObjectPrx end_getPublisher(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getPublisher(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::ObjectPrx getNonReplicatedPublisher(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getNonReplicatedPublisher(_iceI_begin_getNonReplicatedPublisher(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getNonReplicatedPublisher(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getNonReplicatedPublisher(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getNonReplicatedPublisher(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getNonReplicatedPublisher(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getNonReplicatedPublisher(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getNonReplicatedPublisher(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getNonReplicatedPublisher(const ::IceStorm::Callback_Topic_getNonReplicatedPublisherPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getNonReplicatedPublisher(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getNonReplicatedPublisher(const ::Ice::Context& context, const ::IceStorm::Callback_Topic_getNonReplicatedPublisherPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getNonReplicatedPublisher(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::Ice::ObjectPrx end_getNonReplicatedPublisher(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getNonReplicatedPublisher(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::ObjectPrx subscribeAndGetPublisher(const ::IceStorm::QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_subscribeAndGetPublisher(_iceI_begin_subscribeAndGetPublisher(theQoS, subscriber, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_subscribeAndGetPublisher(const ::IceStorm::QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_subscribeAndGetPublisher(theQoS, subscriber, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_subscribeAndGetPublisher(const ::IceStorm::QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_subscribeAndGetPublisher(theQoS, subscriber, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_subscribeAndGetPublisher(const ::IceStorm::QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_subscribeAndGetPublisher(theQoS, subscriber, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_subscribeAndGetPublisher(const ::IceStorm::QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::IceStorm::Callback_Topic_subscribeAndGetPublisherPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_subscribeAndGetPublisher(theQoS, subscriber, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_subscribeAndGetPublisher(const ::IceStorm::QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context, const ::IceStorm::Callback_Topic_subscribeAndGetPublisherPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_subscribeAndGetPublisher(theQoS, subscriber, context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::Ice::ObjectPrx end_subscribeAndGetPublisher(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_subscribeAndGetPublisher(const ::IceStorm::QoS&, const ::Ice::ObjectPrx&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) void unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        end_unsubscribe(_iceI_begin_unsubscribe(subscriber, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_unsubscribe(subscriber, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unsubscribe(subscriber, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unsubscribe(subscriber, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::IceStorm::Callback_Topic_unsubscribePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unsubscribe(subscriber, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::Ice::Context& context, const ::IceStorm::Callback_Topic_unsubscribePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unsubscribe(subscriber, context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) void end_unsubscribe(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_unsubscribe(const ::Ice::ObjectPrx&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) void link(const ::IceStorm::TopicPrx& linkTo, ::Ice::Int cost, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        end_link(_iceI_begin_link(linkTo, cost, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_link(const ::IceStorm::TopicPrx& linkTo, ::Ice::Int cost, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_link(linkTo, cost, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_link(const ::IceStorm::TopicPrx& linkTo, ::Ice::Int cost, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_link(linkTo, cost, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_link(const ::IceStorm::TopicPrx& linkTo, ::Ice::Int cost, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_link(linkTo, cost, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_link(const ::IceStorm::TopicPrx& linkTo, ::Ice::Int cost, const ::IceStorm::Callback_Topic_linkPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_link(linkTo, cost, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_link(const ::IceStorm::TopicPrx& linkTo, ::Ice::Int cost, const ::Ice::Context& context, const ::IceStorm::Callback_Topic_linkPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_link(linkTo, cost, context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) void end_link(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_link(const ::IceStorm::TopicPrx&, ::Ice::Int, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) void unlink(const ::IceStorm::TopicPrx& linkTo, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        end_unlink(_iceI_begin_unlink(linkTo, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_unlink(const ::IceStorm::TopicPrx& linkTo, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_unlink(linkTo, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_unlink(const ::IceStorm::TopicPrx& linkTo, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unlink(linkTo, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_unlink(const ::IceStorm::TopicPrx& linkTo, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unlink(linkTo, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_unlink(const ::IceStorm::TopicPrx& linkTo, const ::IceStorm::Callback_Topic_unlinkPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unlink(linkTo, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_unlink(const ::IceStorm::TopicPrx& linkTo, const ::Ice::Context& context, const ::IceStorm::Callback_Topic_unlinkPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_unlink(linkTo, context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) void end_unlink(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_unlink(const ::IceStorm::TopicPrx&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::LinkInfoSeq getLinkInfoSeq(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getLinkInfoSeq(_iceI_begin_getLinkInfoSeq(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getLinkInfoSeq(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getLinkInfoSeq(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getLinkInfoSeq(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getLinkInfoSeq(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getLinkInfoSeq(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getLinkInfoSeq(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getLinkInfoSeq(const ::IceStorm::Callback_Topic_getLinkInfoSeqPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getLinkInfoSeq(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getLinkInfoSeq(const ::Ice::Context& context, const ::IceStorm::Callback_Topic_getLinkInfoSeqPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getLinkInfoSeq(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::LinkInfoSeq end_getLinkInfoSeq(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getLinkInfoSeq(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::IdentitySeq getSubscribers(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getSubscribers(_iceI_begin_getSubscribers(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getSubscribers(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getSubscribers(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getSubscribers(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSubscribers(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getSubscribers(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSubscribers(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getSubscribers(const ::IceStorm::Callback_Topic_getSubscribersPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSubscribers(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getSubscribers(const ::Ice::Context& context, const ::IceStorm::Callback_Topic_getSubscribersPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSubscribers(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::Ice::IdentitySeq end_getSubscribers(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getSubscribers(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) void destroy(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        end_destroy(_iceI_begin_destroy(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_destroy(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_destroy(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_destroy(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_destroy(const ::IceStorm::Callback_Topic_destroyPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_destroy(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_destroy(const ::Ice::Context& context, const ::IceStorm::Callback_Topic_destroyPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_destroy(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) void end_destroy(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_destroy(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
protected:
 
    ICE_MEMBER(ICESTORM_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
};
 
class ICE_CLASS(ICESTORM_API) TopicManager : public virtual ::Ice::Proxy<TopicManager, ::IceProxy::Ice::Object>
{
public:
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicPrx create(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_create(_iceI_begin_create(name, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_create(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_create(name, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_create(const ::std::string& name, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_create(name, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_create(const ::std::string& name, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_create(name, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_create(const ::std::string& name, const ::IceStorm::Callback_TopicManager_createPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_create(name, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_create(const ::std::string& name, const ::Ice::Context& context, const ::IceStorm::Callback_TopicManager_createPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_create(name, context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicPrx end_create(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_create(const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicPrx retrieve(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_retrieve(_iceI_begin_retrieve(name, context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_retrieve(const ::std::string& name, const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_retrieve(name, context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_retrieve(const ::std::string& name, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieve(name, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_retrieve(const ::std::string& name, const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieve(name, context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_retrieve(const ::std::string& name, const ::IceStorm::Callback_TopicManager_retrievePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieve(name, ::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_retrieve(const ::std::string& name, const ::Ice::Context& context, const ::IceStorm::Callback_TopicManager_retrievePtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieve(name, context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicPrx end_retrieve(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_retrieve(const ::std::string&, const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicDict retrieveAll(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_retrieveAll(_iceI_begin_retrieveAll(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_retrieveAll(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_retrieveAll(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_retrieveAll(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieveAll(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_retrieveAll(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieveAll(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_retrieveAll(const ::IceStorm::Callback_TopicManager_retrieveAllPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieveAll(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_retrieveAll(const ::Ice::Context& context, const ::IceStorm::Callback_TopicManager_retrieveAllPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_retrieveAll(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicDict end_retrieveAll(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_retrieveAll(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getSliceChecksums(_iceI_begin_getSliceChecksums(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getSliceChecksums(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSliceChecksums(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSliceChecksums(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::IceStorm::Callback_TopicManager_getSliceChecksumsPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSliceChecksums(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getSliceChecksums(const ::Ice::Context& context, const ::IceStorm::Callback_TopicManager_getSliceChecksumsPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getSliceChecksums(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::Ice::SliceChecksumDict end_getSliceChecksums(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getSliceChecksums(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
protected:
 
    ICE_MEMBER(ICESTORM_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
};
 
class ICE_CLASS(ICESTORM_API) Finder : public virtual ::Ice::Proxy<Finder, ::IceProxy::Ice::Object>
{
public:
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicManagerPrx getTopicManager(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return end_getTopicManager(_iceI_begin_getTopicManager(context, ::IceInternal::dummyCallback, 0, true));
    }
 
    ::Ice::AsyncResultPtr begin_getTopicManager(const ::Ice::Context& context = ::Ice::noExplicitContext)
    {
        return _iceI_begin_getTopicManager(context, ::IceInternal::dummyCallback, 0);
    }
 
    ::Ice::AsyncResultPtr begin_getTopicManager(const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTopicManager(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getTopicManager(const ::Ice::Context& context, const ::Ice::CallbackPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTopicManager(context, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getTopicManager(const ::IceStorm::Callback_Finder_getTopicManagerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTopicManager(::Ice::noExplicitContext, cb, cookie);
    }
 
    ::Ice::AsyncResultPtr begin_getTopicManager(const ::Ice::Context& context, const ::IceStorm::Callback_Finder_getTopicManagerPtr& cb, const ::Ice::LocalObjectPtr& cookie = 0)
    {
        return _iceI_begin_getTopicManager(context, cb, cookie);
    }
 
    ICE_MEMBER(ICESTORM_API) ::IceStorm::TopicManagerPrx end_getTopicManager(const ::Ice::AsyncResultPtr& result);
 
private:
 
    ICE_MEMBER(ICESTORM_API) ::Ice::AsyncResultPtr _iceI_begin_getTopicManager(const ::Ice::Context&, const ::IceInternal::CallbackBasePtr&, const ::Ice::LocalObjectPtr& cookie = 0, bool sync = false);
 
public:
 
    ICE_MEMBER(ICESTORM_API) static const ::std::string& ice_staticId();
 
protected:
 
    ICE_MEMBER(ICESTORM_API) virtual ::IceProxy::Ice::Object* _newInstance() const;
};
 
}
 
}
 
namespace IceStorm
{
 
class ICESTORM_API Topic : public virtual ::Ice::Object
{
public:
 
    typedef TopicPrx ProxyType;
    typedef TopicPtr PointerType;
 
    virtual ~Topic();
 
#ifdef ICE_CPP11_COMPILER
    Topic() = default;
    Topic(const Topic&) = default;
    Topic& operator=(const Topic&) = default;
#endif
 
    virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    static const ::std::string& ice_staticId();
 
    virtual ::std::string getName(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_getName(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::ObjectPrx getPublisher(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_getPublisher(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::ObjectPrx getNonReplicatedPublisher(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_getNonReplicatedPublisher(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::ObjectPrx subscribeAndGetPublisher(const QoS& theQoS, const ::Ice::ObjectPrx& subscriber, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_subscribeAndGetPublisher(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void unsubscribe(const ::Ice::ObjectPrx& subscriber, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_unsubscribe(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void link(const TopicPrx& linkTo, ::Ice::Int cost, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_link(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual void unlink(const TopicPrx& linkTo, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_unlink(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual LinkInfoSeq getLinkInfoSeq(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_getLinkInfoSeq(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::IdentitySeq getSubscribers(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_getSubscribers(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual void destroy(const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_destroy(::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 Topic& lhs, const Topic& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
}
 
inline bool operator<(const Topic& lhs, const Topic& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
}
 
class ICESTORM_API TopicManager : public virtual ::Ice::Object
{
public:
 
    typedef TopicManagerPrx ProxyType;
    typedef TopicManagerPtr PointerType;
 
    virtual ~TopicManager();
 
#ifdef ICE_CPP11_COMPILER
    TopicManager() = default;
    TopicManager(const TopicManager&) = default;
    TopicManager& operator=(const TopicManager&) = default;
#endif
 
    virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    static const ::std::string& ice_staticId();
 
    virtual TopicPrx create(const ::std::string& name, const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_create(::IceInternal::Incoming&, const ::Ice::Current&);
 
    virtual TopicPrx retrieve(const ::std::string& name, const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_retrieve(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual TopicDict retrieveAll(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_retrieveAll(::IceInternal::Incoming&, const ::Ice::Current&) const;
 
    virtual ::Ice::SliceChecksumDict getSliceChecksums(const ::Ice::Current& current = ::Ice::emptyCurrent) const = 0;
    bool _iceD_getSliceChecksums(::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 TopicManager& lhs, const TopicManager& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
}
 
inline bool operator<(const TopicManager& lhs, const TopicManager& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
}
 
class ICESTORM_API Finder : public virtual ::Ice::Object
{
public:
 
    typedef FinderPrx ProxyType;
    typedef FinderPtr PointerType;
 
    virtual ~Finder();
 
#ifdef ICE_CPP11_COMPILER
    Finder() = default;
    Finder(const Finder&) = default;
    Finder& operator=(const Finder&) = default;
#endif
 
    virtual bool ice_isA(const ::std::string& id, const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    virtual ::std::vector< ::std::string> ice_ids(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    virtual const ::std::string& ice_id(const ::Ice::Current& current = ::Ice::emptyCurrent) const;
 
    static const ::std::string& ice_staticId();
 
    virtual TopicManagerPrx getTopicManager(const ::Ice::Current& current = ::Ice::emptyCurrent) = 0;
    bool _iceD_getTopicManager(::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 Finder& lhs, const Finder& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) == static_cast<const ::Ice::Object&>(rhs);
}
 
inline bool operator<(const Finder& lhs, const Finder& rhs)
{
    return static_cast<const ::Ice::Object&>(lhs) < static_cast<const ::Ice::Object&>(rhs);
}
 
}
 
namespace Ice
{
 
template<>
struct StreamableTraits< ::IceStorm::LinkInfo>
{
    static const StreamHelperCategory helper = StreamHelperCategoryStruct;
    static const int minWireSize = 7;
    static const bool fixedLength = false;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::LinkInfo, S>
{
    static void write(S* ostr, const ::IceStorm::LinkInfo& v)
    {
        ostr->write(v.theTopic);
        ostr->write(v.name);
        ostr->write(v.cost);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::LinkInfo, S>
{
    static void read(S* istr, ::IceStorm::LinkInfo& v)
    {
        istr->read(v.theTopic);
        istr->read(v.name);
        istr->read(v.cost);
    }
};
 
template<>
struct StreamableTraits< ::IceStorm::LinkExists>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::LinkExists, S>
{
    static void write(S* ostr, const ::IceStorm::LinkExists& v)
    {
        ostr->write(v.name);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::LinkExists, S>
{
    static void read(S* istr, ::IceStorm::LinkExists& v)
    {
        istr->read(v.name);
    }
};
 
template<>
struct StreamableTraits< ::IceStorm::NoSuchLink>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::NoSuchLink, S>
{
    static void write(S* ostr, const ::IceStorm::NoSuchLink& v)
    {
        ostr->write(v.name);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::NoSuchLink, S>
{
    static void read(S* istr, ::IceStorm::NoSuchLink& v)
    {
        istr->read(v.name);
    }
};
 
template<>
struct StreamableTraits< ::IceStorm::AlreadySubscribed>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<>
struct StreamableTraits< ::IceStorm::InvalidSubscriber>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::InvalidSubscriber, S>
{
    static void write(S* ostr, const ::IceStorm::InvalidSubscriber& v)
    {
        ostr->write(v.reason);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::InvalidSubscriber, S>
{
    static void read(S* istr, ::IceStorm::InvalidSubscriber& v)
    {
        istr->read(v.reason);
    }
};
 
template<>
struct StreamableTraits< ::IceStorm::BadQoS>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::BadQoS, S>
{
    static void write(S* ostr, const ::IceStorm::BadQoS& v)
    {
        ostr->write(v.reason);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::BadQoS, S>
{
    static void read(S* istr, ::IceStorm::BadQoS& v)
    {
        istr->read(v.reason);
    }
};
 
template<>
struct StreamableTraits< ::IceStorm::TopicExists>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::TopicExists, S>
{
    static void write(S* ostr, const ::IceStorm::TopicExists& v)
    {
        ostr->write(v.name);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::TopicExists, S>
{
    static void read(S* istr, ::IceStorm::TopicExists& v)
    {
        istr->read(v.name);
    }
};
 
template<>
struct StreamableTraits< ::IceStorm::NoSuchTopic>
{
    static const StreamHelperCategory helper = StreamHelperCategoryUserException;
};
 
template<typename S>
struct StreamWriter< ::IceStorm::NoSuchTopic, S>
{
    static void write(S* ostr, const ::IceStorm::NoSuchTopic& v)
    {
        ostr->write(v.name);
    }
};
 
template<typename S>
struct StreamReader< ::IceStorm::NoSuchTopic, S>
{
    static void read(S* istr, ::IceStorm::NoSuchTopic& v)
    {
        istr->read(v.name);
    }
};
 
}
 
namespace IceStorm
{
 
template<class T>
class CallbackNC_Topic_getName : public Callback_Topic_getName_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 ::std::string&);
 
    CallbackNC_Topic_getName(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::std::string ret;
        try
        {
            ret = proxy->end_getName(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_Topic_getNamePtr
newCallback_Topic_getName(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getName<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_getNamePtr
newCallback_Topic_getName(T* instance, void (T::*cb)(const ::std::string&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getName<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_getName : public Callback_Topic_getName_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 ::std::string&, const CT&);
 
    Callback_Topic_getName(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::std::string ret;
        try
        {
            ret = proxy->end_getName(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_Topic_getNamePtr
newCallback_Topic_getName(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_getName<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_getNamePtr
newCallback_Topic_getName(T* instance, void (T::*cb)(const ::std::string&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_getName<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_getPublisher : public Callback_Topic_getPublisher_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_Topic_getPublisher(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::ObjectPrx ret;
        try
        {
            ret = proxy->end_getPublisher(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_Topic_getPublisherPtr
newCallback_Topic_getPublisher(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_Topic_getPublisher<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_getPublisherPtr
newCallback_Topic_getPublisher(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getPublisher<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_getPublisher : public Callback_Topic_getPublisher_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_Topic_getPublisher(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::ObjectPrx ret;
        try
        {
            ret = proxy->end_getPublisher(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_Topic_getPublisherPtr
newCallback_Topic_getPublisher(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_Topic_getPublisher<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_getPublisherPtr
newCallback_Topic_getPublisher(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_Topic_getPublisher<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_getNonReplicatedPublisher : public Callback_Topic_getNonReplicatedPublisher_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_Topic_getNonReplicatedPublisher(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::ObjectPrx ret;
        try
        {
            ret = proxy->end_getNonReplicatedPublisher(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_Topic_getNonReplicatedPublisherPtr
newCallback_Topic_getNonReplicatedPublisher(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_Topic_getNonReplicatedPublisher<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_getNonReplicatedPublisherPtr
newCallback_Topic_getNonReplicatedPublisher(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getNonReplicatedPublisher<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_getNonReplicatedPublisher : public Callback_Topic_getNonReplicatedPublisher_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_Topic_getNonReplicatedPublisher(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::ObjectPrx ret;
        try
        {
            ret = proxy->end_getNonReplicatedPublisher(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_Topic_getNonReplicatedPublisherPtr
newCallback_Topic_getNonReplicatedPublisher(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_Topic_getNonReplicatedPublisher<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_getNonReplicatedPublisherPtr
newCallback_Topic_getNonReplicatedPublisher(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_Topic_getNonReplicatedPublisher<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_subscribeAndGetPublisher : public Callback_Topic_subscribeAndGetPublisher_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_Topic_subscribeAndGetPublisher(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::ObjectPrx ret;
        try
        {
            ret = proxy->end_subscribeAndGetPublisher(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_Topic_subscribeAndGetPublisherPtr
newCallback_Topic_subscribeAndGetPublisher(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_Topic_subscribeAndGetPublisher<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_subscribeAndGetPublisherPtr
newCallback_Topic_subscribeAndGetPublisher(T* instance, void (T::*cb)(const ::Ice::ObjectPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_subscribeAndGetPublisher<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_subscribeAndGetPublisher : public Callback_Topic_subscribeAndGetPublisher_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_Topic_subscribeAndGetPublisher(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::ObjectPrx ret;
        try
        {
            ret = proxy->end_subscribeAndGetPublisher(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_Topic_subscribeAndGetPublisherPtr
newCallback_Topic_subscribeAndGetPublisher(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_Topic_subscribeAndGetPublisher<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_subscribeAndGetPublisherPtr
newCallback_Topic_subscribeAndGetPublisher(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_Topic_subscribeAndGetPublisher<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_unsubscribe : public Callback_Topic_unsubscribe_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_Topic_unsubscribe(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};
 
template<class T> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unsubscribe<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unsubscribe<T>(instance, 0, excb, sentcb);
}
 
template<class T> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unsubscribe<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unsubscribe<T>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_unsubscribe : public Callback_Topic_unsubscribe_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_Topic_unsubscribe(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};
 
template<class T, typename CT> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(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_Topic_unsubscribe<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_unsubscribe<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(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_Topic_unsubscribe<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_unsubscribePtr
newCallback_Topic_unsubscribe(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_unsubscribe<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_link : public Callback_Topic_link_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_Topic_link(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        try
        {
            proxy->end_link(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_Topic_linkPtr
newCallback_Topic_link(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_link<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_linkPtr
newCallback_Topic_link(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_link<T>(instance, 0, excb, sentcb);
}
 
template<class T> Callback_Topic_linkPtr
newCallback_Topic_link(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_link<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_linkPtr
newCallback_Topic_link(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_link<T>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_link : public Callback_Topic_link_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_Topic_link(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        try
        {
            proxy->end_link(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_Topic_linkPtr
newCallback_Topic_link(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_Topic_link<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_linkPtr
newCallback_Topic_link(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_link<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_linkPtr
newCallback_Topic_link(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_Topic_link<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_linkPtr
newCallback_Topic_link(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_link<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_unlink : public Callback_Topic_unlink_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_Topic_unlink(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        try
        {
            proxy->end_unlink(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_Topic_unlinkPtr
newCallback_Topic_unlink(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unlink<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_unlinkPtr
newCallback_Topic_unlink(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unlink<T>(instance, 0, excb, sentcb);
}
 
template<class T> Callback_Topic_unlinkPtr
newCallback_Topic_unlink(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unlink<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_unlinkPtr
newCallback_Topic_unlink(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_unlink<T>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_unlink : public Callback_Topic_unlink_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_Topic_unlink(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        try
        {
            proxy->end_unlink(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_Topic_unlinkPtr
newCallback_Topic_unlink(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_Topic_unlink<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_unlinkPtr
newCallback_Topic_unlink(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_unlink<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_unlinkPtr
newCallback_Topic_unlink(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_Topic_unlink<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_unlinkPtr
newCallback_Topic_unlink(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_unlink<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_getLinkInfoSeq : public Callback_Topic_getLinkInfoSeq_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 LinkInfoSeq&);
 
    CallbackNC_Topic_getLinkInfoSeq(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        LinkInfoSeq ret;
        try
        {
            ret = proxy->end_getLinkInfoSeq(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_Topic_getLinkInfoSeqPtr
newCallback_Topic_getLinkInfoSeq(const IceUtil::Handle<T>& instance, void (T::*cb)(const LinkInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getLinkInfoSeq<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_getLinkInfoSeqPtr
newCallback_Topic_getLinkInfoSeq(T* instance, void (T::*cb)(const LinkInfoSeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getLinkInfoSeq<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_getLinkInfoSeq : public Callback_Topic_getLinkInfoSeq_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 LinkInfoSeq&, const CT&);
 
    Callback_Topic_getLinkInfoSeq(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        LinkInfoSeq ret;
        try
        {
            ret = proxy->end_getLinkInfoSeq(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_Topic_getLinkInfoSeqPtr
newCallback_Topic_getLinkInfoSeq(const IceUtil::Handle<T>& instance, void (T::*cb)(const LinkInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_getLinkInfoSeq<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_getLinkInfoSeqPtr
newCallback_Topic_getLinkInfoSeq(T* instance, void (T::*cb)(const LinkInfoSeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_getLinkInfoSeq<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_getSubscribers : public Callback_Topic_getSubscribers_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::IdentitySeq&);
 
    CallbackNC_Topic_getSubscribers(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::IdentitySeq ret;
        try
        {
            ret = proxy->end_getSubscribers(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_Topic_getSubscribersPtr
newCallback_Topic_getSubscribers(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IdentitySeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getSubscribers<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_getSubscribersPtr
newCallback_Topic_getSubscribers(T* instance, void (T::*cb)(const ::Ice::IdentitySeq&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_getSubscribers<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_getSubscribers : public Callback_Topic_getSubscribers_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::IdentitySeq&, const CT&);
 
    Callback_Topic_getSubscribers(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
    {
        TopicPrx proxy = TopicPrx::uncheckedCast(result->getProxy());
        ::Ice::IdentitySeq ret;
        try
        {
            ret = proxy->end_getSubscribers(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_Topic_getSubscribersPtr
newCallback_Topic_getSubscribers(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::IdentitySeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_getSubscribers<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_getSubscribersPtr
newCallback_Topic_getSubscribers(T* instance, void (T::*cb)(const ::Ice::IdentitySeq&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_getSubscribers<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Topic_destroy : public Callback_Topic_destroy_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_Topic_destroy(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallbackNC<T>(obj, cb, excb, sentcb)
    {
    }
};
 
template<class T> Callback_Topic_destroyPtr
newCallback_Topic_destroy(const IceUtil::Handle<T>& instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_destroy<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_destroyPtr
newCallback_Topic_destroy(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_destroy<T>(instance, 0, excb, sentcb);
}
 
template<class T> Callback_Topic_destroyPtr
newCallback_Topic_destroy(T* instance, void (T::*cb)(), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_destroy<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Topic_destroyPtr
newCallback_Topic_destroy(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Topic_destroy<T>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Topic_destroy : public Callback_Topic_destroy_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_Topic_destroy(const TPtr& obj, Response cb, Exception excb, Sent sentcb)
        : ::IceInternal::OnewayCallback<T, CT>(obj, cb, excb, sentcb)
    {
    }
};
 
template<class T, typename CT> Callback_Topic_destroyPtr
newCallback_Topic_destroy(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_Topic_destroy<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_destroyPtr
newCallback_Topic_destroy(const IceUtil::Handle<T>& instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_destroy<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_destroyPtr
newCallback_Topic_destroy(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_Topic_destroy<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Topic_destroyPtr
newCallback_Topic_destroy(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Topic_destroy<T, CT>(instance, 0, excb, sentcb);
}
 
template<class T>
class CallbackNC_TopicManager_create : public Callback_TopicManager_create_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 TopicPrx&);
 
    CallbackNC_TopicManager_create(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        TopicPrx ret;
        try
        {
            ret = proxy->end_create(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_TopicManager_createPtr
newCallback_TopicManager_create(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_create<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_TopicManager_createPtr
newCallback_TopicManager_create(T* instance, void (T::*cb)(const TopicPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_create<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_TopicManager_create : public Callback_TopicManager_create_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 TopicPrx&, const CT&);
 
    Callback_TopicManager_create(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        TopicPrx ret;
        try
        {
            ret = proxy->end_create(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_TopicManager_createPtr
newCallback_TopicManager_create(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_create<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_TopicManager_createPtr
newCallback_TopicManager_create(T* instance, void (T::*cb)(const TopicPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_create<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_TopicManager_retrieve : public Callback_TopicManager_retrieve_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 TopicPrx&);
 
    CallbackNC_TopicManager_retrieve(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        TopicPrx ret;
        try
        {
            ret = proxy->end_retrieve(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_TopicManager_retrievePtr
newCallback_TopicManager_retrieve(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_retrieve<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_TopicManager_retrievePtr
newCallback_TopicManager_retrieve(T* instance, void (T::*cb)(const TopicPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_retrieve<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_TopicManager_retrieve : public Callback_TopicManager_retrieve_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 TopicPrx&, const CT&);
 
    Callback_TopicManager_retrieve(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        TopicPrx ret;
        try
        {
            ret = proxy->end_retrieve(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_TopicManager_retrievePtr
newCallback_TopicManager_retrieve(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_retrieve<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_TopicManager_retrievePtr
newCallback_TopicManager_retrieve(T* instance, void (T::*cb)(const TopicPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_retrieve<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_TopicManager_retrieveAll : public Callback_TopicManager_retrieveAll_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 TopicDict&);
 
    CallbackNC_TopicManager_retrieveAll(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        TopicDict ret;
        try
        {
            ret = proxy->end_retrieveAll(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_TopicManager_retrieveAllPtr
newCallback_TopicManager_retrieveAll(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_retrieveAll<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_TopicManager_retrieveAllPtr
newCallback_TopicManager_retrieveAll(T* instance, void (T::*cb)(const TopicDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_retrieveAll<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_TopicManager_retrieveAll : public Callback_TopicManager_retrieveAll_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 TopicDict&, const CT&);
 
    Callback_TopicManager_retrieveAll(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        TopicDict ret;
        try
        {
            ret = proxy->end_retrieveAll(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_TopicManager_retrieveAllPtr
newCallback_TopicManager_retrieveAll(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_retrieveAll<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_TopicManager_retrieveAllPtr
newCallback_TopicManager_retrieveAll(T* instance, void (T::*cb)(const TopicDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_retrieveAll<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_TopicManager_getSliceChecksums : public Callback_TopicManager_getSliceChecksums_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::SliceChecksumDict&);
 
    CallbackNC_TopicManager_getSliceChecksums(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        ::Ice::SliceChecksumDict ret;
        try
        {
            ret = proxy->end_getSliceChecksums(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_TopicManager_getSliceChecksumsPtr
newCallback_TopicManager_getSliceChecksums(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::SliceChecksumDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_getSliceChecksums<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_TopicManager_getSliceChecksumsPtr
newCallback_TopicManager_getSliceChecksums(T* instance, void (T::*cb)(const ::Ice::SliceChecksumDict&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_TopicManager_getSliceChecksums<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_TopicManager_getSliceChecksums : public Callback_TopicManager_getSliceChecksums_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::SliceChecksumDict&, const CT&);
 
    Callback_TopicManager_getSliceChecksums(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
    {
        TopicManagerPrx proxy = TopicManagerPrx::uncheckedCast(result->getProxy());
        ::Ice::SliceChecksumDict ret;
        try
        {
            ret = proxy->end_getSliceChecksums(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_TopicManager_getSliceChecksumsPtr
newCallback_TopicManager_getSliceChecksums(const IceUtil::Handle<T>& instance, void (T::*cb)(const ::Ice::SliceChecksumDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_getSliceChecksums<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_TopicManager_getSliceChecksumsPtr
newCallback_TopicManager_getSliceChecksums(T* instance, void (T::*cb)(const ::Ice::SliceChecksumDict&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_TopicManager_getSliceChecksums<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T>
class CallbackNC_Finder_getTopicManager : public Callback_Finder_getTopicManager_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 TopicManagerPrx&);
 
    CallbackNC_Finder_getTopicManager(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
    {
        FinderPrx proxy = FinderPrx::uncheckedCast(result->getProxy());
        TopicManagerPrx ret;
        try
        {
            ret = proxy->end_getTopicManager(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_Finder_getTopicManagerPtr
newCallback_Finder_getTopicManager(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicManagerPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Finder_getTopicManager<T>(instance, cb, excb, sentcb);
}
 
template<class T> Callback_Finder_getTopicManagerPtr
newCallback_Finder_getTopicManager(T* instance, void (T::*cb)(const TopicManagerPrx&), void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
{
    return new CallbackNC_Finder_getTopicManager<T>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT>
class Callback_Finder_getTopicManager : public Callback_Finder_getTopicManager_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 TopicManagerPrx&, const CT&);
 
    Callback_Finder_getTopicManager(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
    {
        FinderPrx proxy = FinderPrx::uncheckedCast(result->getProxy());
        TopicManagerPrx ret;
        try
        {
            ret = proxy->end_getTopicManager(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_Finder_getTopicManagerPtr
newCallback_Finder_getTopicManager(const IceUtil::Handle<T>& instance, void (T::*cb)(const TopicManagerPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Finder_getTopicManager<T, CT>(instance, cb, excb, sentcb);
}
 
template<class T, typename CT> Callback_Finder_getTopicManagerPtr
newCallback_Finder_getTopicManager(T* instance, void (T::*cb)(const TopicManagerPrx&, const CT&), void (T::*excb)(const ::Ice::Exception&, const CT&), void (T::*sentcb)(bool, const CT&) = 0)
{
    return new Callback_Finder_getTopicManager<T, CT>(instance, cb, excb, sentcb);
}
 
}
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif