Instrumentation.h

Go to the documentation of this file.

// **********************************************************************
//
// Copyright (c) 2003-2017 ZeroC, Inc. All rights reserved.
//
// This copy of Ice is licensed to you under the terms described in the
// ICE_LICENSE file included in this distribution.
//
// **********************************************************************
//
// Ice version 3.7.0
//
// <auto-generated>
//
// Generated from file `Instrumentation.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __IceStorm_Instrumentation_h__
#define __IceStorm_Instrumentation_h__
 
#include <Ice/Comparable.h>
#include <Ice/Exception.h>
#include <Ice/ExceptionHelpers.h>
#include <Ice/FactoryTableInit.h>
#include <Ice/GCObject.h>
#include <Ice/Incoming.h>
#include <Ice/Instrumentation.h>
#include <Ice/LocalObject.h>
#include <Ice/Object.h>
#include <Ice/ObjectF.h>
#include <Ice/Optional.h>
#include <Ice/Proxy.h>
#include <Ice/ProxyF.h>
#include <Ice/StreamHelpers.h>
#include <Ice/Value.h>
#include <Ice/ValueF.h>
#include <IceStorm/IceStorm.h>
#include <IceUtil/PushDisableWarnings.h>
#include <IceUtil/ScopedArray.h>
#include <IceUtil/UndefSysMacros.h>
 
#ifndef ICE_IGNORE_VERSION
#if ICE_INT_VERSION / 100 != 307
#error Ice version mismatch!
#endif
#if ICE_INT_VERSION % 100 > 50
#error Beta header file detected
#endif
#if ICE_INT_VERSION % 100 < 0
#error Ice patch level mismatch!
#endif
#endif
 
#ifdef ICE_CPP11_MAPPING // C++11 mapping
 
namespace IceStorm::Instrumentation
{
 
    class TopicObserver;
    class SubscriberObserver;
    class ObserverUpdater;
    class TopicManagerObserver;
 
} // namespace IceStorm::Instrumentation
 
namespace IceStorm::Instrumentation
{
 
    enum class SubscriberState : unsigned char
    {
        SubscriberStateOnline,
        SubscriberStateOffline,
        SubscriberStateError
    };
 
} // namespace IceStorm::Instrumentation
 
namespace IceStorm::Instrumentation
{
 
    class TopicObserver : public virtual ::Ice::Instrumentation::Observer
    {
    public:
        virtual ~TopicObserver();
 
        virtual void published() = 0;
 
        virtual void forwarded() = 0;
    };
 
    class SubscriberObserver : public virtual ::Ice::Instrumentation::Observer
    {
    public:
        virtual ~SubscriberObserver();
 
        virtual void queued(int) = 0;
 
        virtual void outstanding(int) = 0;
 
        virtual void delivered(int) = 0;
    };
 
    class ObserverUpdater
    {
    public:
        virtual ~ObserverUpdater();
 
        virtual void updateTopicObservers() = 0;
 
        virtual void updateSubscriberObservers() = 0;
    };
 
    class TopicManagerObserver
    {
    public:
        virtual ~TopicManagerObserver();
 
        virtual ::std::shared_ptr<::IceStorm::Instrumentation::TopicObserver>
        getTopicObserver(const ::std::string&,
                         const ::std::string&,
                         const ::std::shared_ptr<::IceStorm::Instrumentation::TopicObserver>&) = 0;
 
        virtual ::std::shared_ptr<::IceStorm::Instrumentation::SubscriberObserver>
        getSubscriberObserver(
            const ::std::string&,
            const ::std::string&,
            const ::std::shared_ptr<::Ice::ObjectPrx>&,
            const ::IceStorm::QoS&,
            const ::std::shared_ptr<::IceStorm::TopicPrx>&,
            ::IceStorm::Instrumentation::SubscriberState,
            const ::std::shared_ptr<::IceStorm::Instrumentation::SubscriberObserver>&) = 0;
 
        virtual void setObserverUpdater(
            const ::std::shared_ptr<::IceStorm::Instrumentation::ObserverUpdater>&) = 0;
    };
 
} // namespace IceStorm::Instrumentation
 
namespace Ice
{
 
    template <>
    struct StreamableTraits<::IceStorm::Instrumentation::SubscriberState>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryEnum;
        static const int minValue = 0;
        static const int maxValue = 2;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };
 
} // namespace Ice
 
namespace IceStorm::Instrumentation
{
 
    using TopicObserverPtr = ::std::shared_ptr<TopicObserver>;
 
    using SubscriberObserverPtr = ::std::shared_ptr<SubscriberObserver>;
 
    using ObserverUpdaterPtr = ::std::shared_ptr<ObserverUpdater>;
 
    using TopicManagerObserverPtr = ::std::shared_ptr<TopicManagerObserver>;
 
} // namespace IceStorm::Instrumentation
 
 
#else // C++98 mapping
 
namespace IceProxy
{
 
}
 
namespace IceStorm::Instrumentation
{
 
    class TopicObserver;
    ::Ice::LocalObject* upCast(::IceStorm::Instrumentation::TopicObserver*);
    typedef ::IceInternal::Handle<::IceStorm::Instrumentation::TopicObserver> TopicObserverPtr;
 
    class SubscriberObserver;
    ::Ice::LocalObject* upCast(::IceStorm::Instrumentation::SubscriberObserver*);
    typedef ::IceInternal::Handle<::IceStorm::Instrumentation::SubscriberObserver>
        SubscriberObserverPtr;
 
    class ObserverUpdater;
    ::Ice::LocalObject* upCast(::IceStorm::Instrumentation::ObserverUpdater*);
    typedef ::IceInternal::Handle<::IceStorm::Instrumentation::ObserverUpdater> ObserverUpdaterPtr;
 
    class TopicManagerObserver;
    ::Ice::LocalObject* upCast(::IceStorm::Instrumentation::TopicManagerObserver*);
    typedef ::IceInternal::Handle<::IceStorm::Instrumentation::TopicManagerObserver>
        TopicManagerObserverPtr;
 
} // namespace IceStorm::Instrumentation
 
namespace IceStorm::Instrumentation
{
 
    enum SubscriberState
    {
        SubscriberStateOnline,
        SubscriberStateOffline,
        SubscriberStateError
    };
 
} // namespace IceStorm::Instrumentation
 
namespace IceProxy
{
 
}
 
namespace IceStorm::Instrumentation
{
 
    class TopicObserver : virtual public ::Ice::Instrumentation::Observer
    {
    public:
        typedef TopicObserverPtr PointerType;
 
        virtual ~TopicObserver();
 
        virtual void published() = 0;
 
        virtual void forwarded() = 0;
    };
 
    inline bool
    operator==(const TopicObserver& lhs, const TopicObserver& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) ==
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    inline bool
    operator<(const TopicObserver& lhs, const TopicObserver& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) <
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    class SubscriberObserver : virtual public ::Ice::Instrumentation::Observer
    {
    public:
        typedef SubscriberObserverPtr PointerType;
 
        virtual ~SubscriberObserver();
 
        virtual void queued(::Ice::Int) = 0;
 
        virtual void outstanding(::Ice::Int) = 0;
 
        virtual void delivered(::Ice::Int) = 0;
    };
 
    inline bool
    operator==(const SubscriberObserver& lhs, const SubscriberObserver& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) ==
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    inline bool
    operator<(const SubscriberObserver& lhs, const SubscriberObserver& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) <
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    class ObserverUpdater : public virtual ::Ice::LocalObject
    {
    public:
        typedef ObserverUpdaterPtr PointerType;
 
        virtual ~ObserverUpdater();
 
        virtual void updateTopicObservers() = 0;
 
        virtual void updateSubscriberObservers() = 0;
    };
 
    inline bool
    operator==(const ObserverUpdater& lhs, const ObserverUpdater& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) ==
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    inline bool
    operator<(const ObserverUpdater& lhs, const ObserverUpdater& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) <
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    class TopicManagerObserver : public virtual ::Ice::LocalObject
    {
    public:
        typedef TopicManagerObserverPtr PointerType;
 
        virtual ~TopicManagerObserver();
 
        virtual ::IceStorm::Instrumentation::TopicObserverPtr
        getTopicObserver(const ::std::string&,
                         const ::std::string&,
                         const ::IceStorm::Instrumentation::TopicObserverPtr&) = 0;
 
        virtual ::IceStorm::Instrumentation::SubscriberObserverPtr
        getSubscriberObserver(const ::std::string&,
                              const ::std::string&,
                              const ::Ice::ObjectPrx&,
                              const ::IceStorm::QoS&,
                              const ::IceStorm::TopicPrx&,
                              ::IceStorm::Instrumentation::SubscriberState,
                              const ::IceStorm::Instrumentation::SubscriberObserverPtr&) = 0;
 
        virtual void setObserverUpdater(const ::IceStorm::Instrumentation::ObserverUpdaterPtr&) = 0;
    };
 
    inline bool
    operator==(const TopicManagerObserver& lhs, const TopicManagerObserver& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) ==
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
    inline bool
    operator<(const TopicManagerObserver& lhs, const TopicManagerObserver& rhs)
    {
        return static_cast<const ::Ice::LocalObject&>(lhs) <
               static_cast<const ::Ice::LocalObject&>(rhs);
    }
 
} // namespace IceStorm::Instrumentation
 
namespace Ice
{
 
    template <>
    struct StreamableTraits<::IceStorm::Instrumentation::SubscriberState>
    {
        static const StreamHelperCategory helper = StreamHelperCategoryEnum;
        static const int minValue = 0;
        static const int maxValue = 2;
        static const int minWireSize = 1;
        static const bool fixedLength = false;
    };
 
} // namespace Ice
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif