Instrumentation.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 `Instrumentation.ice'
//
// Warning: do not edit this file.
//
// </auto-generated>
//
 
#ifndef __Ice_Instrumentation_h__
#define __Ice_Instrumentation_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 <IceUtil/ScopedArray.h>
#include <Ice/Optional.h>
#include <Ice/EndpointF.h>
#include <Ice/ConnectionF.h>
#include <Ice/Current.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 < 10
#       error Ice patch level mismatch!
#   endif
#endif
 
#ifndef ICE_API
#   if defined(ICE_STATIC_LIBS)
#       define ICE_API 
#   elif defined(ICE_API_EXPORTS)
#       define ICE_API ICE_DECLSPEC_EXPORT
#   else
#       define ICE_API ICE_DECLSPEC_IMPORT
#   endif
#endif
 
#ifdef ICE_CPP11_MAPPING // C++11 mapping
 
namespace Ice
{
 
 
namespace Instrumentation
{
 
class Observer;
class ThreadObserver;
class ConnectionObserver;
class DispatchObserver;
class ChildInvocationObserver;
class RemoteObserver;
class CollocatedObserver;
class InvocationObserver;
class ObserverUpdater;
class CommunicatorObserver;
 
}
 
}
 
namespace Ice
{
 
namespace Instrumentation
{
 
enum class ThreadState : unsigned char
{
    ThreadStateIdle,
    ThreadStateInUseForIO,
    ThreadStateInUseForUser,
    ThreadStateInUseForOther
};
 
enum class ConnectionState : unsigned char
{
    ConnectionStateValidating,
    ConnectionStateHolding,
    ConnectionStateActive,
    ConnectionStateClosing,
    ConnectionStateClosed
};
 
}
 
}
 
namespace Ice
{
 
namespace Instrumentation
{
 
class ICE_CLASS(ICE_API) Observer
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~Observer();
 
    virtual void attach() = 0;
 
    virtual void detach() = 0;
 
    virtual void failed(const ::std::string& exceptionName) = 0;
};
 
class ICE_CLASS(ICE_API) ThreadObserver : public virtual ::Ice::Instrumentation::Observer
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ThreadObserver();
 
    virtual void stateChanged(ThreadState oldState, ThreadState newState) = 0;
};
 
class ICE_CLASS(ICE_API) ConnectionObserver : public virtual ::Ice::Instrumentation::Observer
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ConnectionObserver();
 
    virtual void sentBytes(int num) = 0;
 
    virtual void receivedBytes(int num) = 0;
};
 
class ICE_CLASS(ICE_API) DispatchObserver : public virtual ::Ice::Instrumentation::Observer
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~DispatchObserver();
 
    virtual void userException() = 0;
 
    virtual void reply(int size) = 0;
};
 
class ICE_CLASS(ICE_API) ChildInvocationObserver : public virtual ::Ice::Instrumentation::Observer
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ChildInvocationObserver();
 
    virtual void reply(int size) = 0;
};
 
class ICE_CLASS(ICE_API) RemoteObserver : public virtual ::Ice::Instrumentation::ChildInvocationObserver
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~RemoteObserver();
};
 
class ICE_CLASS(ICE_API) CollocatedObserver : public virtual ::Ice::Instrumentation::ChildInvocationObserver
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CollocatedObserver();
};
 
class ICE_CLASS(ICE_API) InvocationObserver : public virtual ::Ice::Instrumentation::Observer
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~InvocationObserver();
 
    virtual void retried() = 0;
 
    virtual void userException() = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::RemoteObserver> getRemoteObserver(const ::std::shared_ptr<::Ice::ConnectionInfo>& con, const ::std::shared_ptr<::Ice::Endpoint>& endpt, int requestId, int size) = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::CollocatedObserver> getCollocatedObserver(const ::std::shared_ptr<::Ice::ObjectAdapter>& adapter, int requestId, int size) = 0;
};
 
class ICE_CLASS(ICE_API) ObserverUpdater
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~ObserverUpdater();
 
    virtual void updateConnectionObservers() = 0;
 
    virtual void updateThreadObservers() = 0;
};
 
class ICE_CLASS(ICE_API) CommunicatorObserver
{
public:
 
    ICE_MEMBER(ICE_API) virtual ~CommunicatorObserver();
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::Observer> getConnectionEstablishmentObserver(const ::std::shared_ptr<::Ice::Endpoint>& endpt, const ::std::string& connector) = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::Observer> getEndpointLookupObserver(const ::std::shared_ptr<::Ice::Endpoint>& endpt) = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::ConnectionObserver> getConnectionObserver(const ::std::shared_ptr<::Ice::ConnectionInfo>& c, const ::std::shared_ptr<::Ice::Endpoint>& e, ConnectionState s, const ::std::shared_ptr<ConnectionObserver>& o) = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::ThreadObserver> getThreadObserver(const ::std::string& parent, const ::std::string& id, ThreadState s, const ::std::shared_ptr<ThreadObserver>& o) = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::InvocationObserver> getInvocationObserver(const ::std::shared_ptr<::Ice::ObjectPrx>& prx, const ::std::string& operation, const ::Ice::Context& ctx) = 0;
 
    virtual ::std::shared_ptr<::Ice::Instrumentation::DispatchObserver> getDispatchObserver(const ::Ice::Current& c, int size) = 0;
 
    virtual void setObserverUpdater(const ::std::shared_ptr<ObserverUpdater>& updater) = 0;
};
 
}
 
}
 
namespace Ice
{
 
}
 
namespace Ice
{
 
namespace Instrumentation
{
 
using ObserverPtr = ::std::shared_ptr<Observer>;
 
using ThreadObserverPtr = ::std::shared_ptr<ThreadObserver>;
 
using ConnectionObserverPtr = ::std::shared_ptr<ConnectionObserver>;
 
using DispatchObserverPtr = ::std::shared_ptr<DispatchObserver>;
 
using ChildInvocationObserverPtr = ::std::shared_ptr<ChildInvocationObserver>;
 
using RemoteObserverPtr = ::std::shared_ptr<RemoteObserver>;
 
using CollocatedObserverPtr = ::std::shared_ptr<CollocatedObserver>;
 
using InvocationObserverPtr = ::std::shared_ptr<InvocationObserver>;
 
using ObserverUpdaterPtr = ::std::shared_ptr<ObserverUpdater>;
 
using CommunicatorObserverPtr = ::std::shared_ptr<CommunicatorObserver>;
 
}
 
}
 
#else // C++98 mapping
 
namespace Ice
{
 
namespace Instrumentation
{
 
class Observer;
ICE_API ::Ice::LocalObject* upCast(Observer*);
typedef ::IceInternal::Handle< Observer> ObserverPtr;
 
class ThreadObserver;
ICE_API ::Ice::LocalObject* upCast(ThreadObserver*);
typedef ::IceInternal::Handle< ThreadObserver> ThreadObserverPtr;
 
class ConnectionObserver;
ICE_API ::Ice::LocalObject* upCast(ConnectionObserver*);
typedef ::IceInternal::Handle< ConnectionObserver> ConnectionObserverPtr;
 
class DispatchObserver;
ICE_API ::Ice::LocalObject* upCast(DispatchObserver*);
typedef ::IceInternal::Handle< DispatchObserver> DispatchObserverPtr;
 
class ChildInvocationObserver;
ICE_API ::Ice::LocalObject* upCast(ChildInvocationObserver*);
typedef ::IceInternal::Handle< ChildInvocationObserver> ChildInvocationObserverPtr;
 
class RemoteObserver;
ICE_API ::Ice::LocalObject* upCast(RemoteObserver*);
typedef ::IceInternal::Handle< RemoteObserver> RemoteObserverPtr;
 
class CollocatedObserver;
ICE_API ::Ice::LocalObject* upCast(CollocatedObserver*);
typedef ::IceInternal::Handle< CollocatedObserver> CollocatedObserverPtr;
 
class InvocationObserver;
ICE_API ::Ice::LocalObject* upCast(InvocationObserver*);
typedef ::IceInternal::Handle< InvocationObserver> InvocationObserverPtr;
 
class ObserverUpdater;
ICE_API ::Ice::LocalObject* upCast(ObserverUpdater*);
typedef ::IceInternal::Handle< ObserverUpdater> ObserverUpdaterPtr;
 
class CommunicatorObserver;
ICE_API ::Ice::LocalObject* upCast(CommunicatorObserver*);
typedef ::IceInternal::Handle< CommunicatorObserver> CommunicatorObserverPtr;
 
}
 
}
 
namespace Ice
{
 
namespace Instrumentation
{
 
enum ThreadState
{
    ThreadStateIdle,
    ThreadStateInUseForIO,
    ThreadStateInUseForUser,
    ThreadStateInUseForOther
};
 
enum ConnectionState
{
    ConnectionStateValidating,
    ConnectionStateHolding,
    ConnectionStateActive,
    ConnectionStateClosing,
    ConnectionStateClosed
};
 
}
 
}
 
namespace Ice
{
 
namespace Instrumentation
{
 
class ICE_API Observer : public virtual ::Ice::LocalObject
{
public:
 
    typedef ObserverPtr PointerType;
 
    virtual ~Observer();
 
#ifdef ICE_CPP11_COMPILER
    Observer() = default;
    Observer(const Observer&) = default;
    Observer& operator=(const Observer&) = default;
#endif
 
    virtual void attach() = 0;
 
    virtual void detach() = 0;
 
    virtual void failed(const ::std::string& exceptionName) = 0;
};
 
inline bool operator==(const Observer& lhs, const Observer& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const Observer& lhs, const Observer& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API ThreadObserver : virtual public Observer
{
public:
 
    typedef ThreadObserverPtr PointerType;
 
    virtual ~ThreadObserver();
 
#ifdef ICE_CPP11_COMPILER
    ThreadObserver() = default;
    ThreadObserver(const ThreadObserver&) = default;
    ThreadObserver& operator=(const ThreadObserver&) = default;
#endif
 
    virtual void stateChanged(ThreadState oldState, ThreadState newState) = 0;
};
 
inline bool operator==(const ThreadObserver& lhs, const ThreadObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const ThreadObserver& lhs, const ThreadObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API ConnectionObserver : virtual public Observer
{
public:
 
    typedef ConnectionObserverPtr PointerType;
 
    virtual ~ConnectionObserver();
 
#ifdef ICE_CPP11_COMPILER
    ConnectionObserver() = default;
    ConnectionObserver(const ConnectionObserver&) = default;
    ConnectionObserver& operator=(const ConnectionObserver&) = default;
#endif
 
    virtual void sentBytes(::Ice::Int num) = 0;
 
    virtual void receivedBytes(::Ice::Int num) = 0;
};
 
inline bool operator==(const ConnectionObserver& lhs, const ConnectionObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const ConnectionObserver& lhs, const ConnectionObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API DispatchObserver : virtual public Observer
{
public:
 
    typedef DispatchObserverPtr PointerType;
 
    virtual ~DispatchObserver();
 
#ifdef ICE_CPP11_COMPILER
    DispatchObserver() = default;
    DispatchObserver(const DispatchObserver&) = default;
    DispatchObserver& operator=(const DispatchObserver&) = default;
#endif
 
    virtual void userException() = 0;
 
    virtual void reply(::Ice::Int size) = 0;
};
 
inline bool operator==(const DispatchObserver& lhs, const DispatchObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const DispatchObserver& lhs, const DispatchObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API ChildInvocationObserver : virtual public Observer
{
public:
 
    typedef ChildInvocationObserverPtr PointerType;
 
    virtual ~ChildInvocationObserver();
 
#ifdef ICE_CPP11_COMPILER
    ChildInvocationObserver() = default;
    ChildInvocationObserver(const ChildInvocationObserver&) = default;
    ChildInvocationObserver& operator=(const ChildInvocationObserver&) = default;
#endif
 
    virtual void reply(::Ice::Int size) = 0;
};
 
inline bool operator==(const ChildInvocationObserver& lhs, const ChildInvocationObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const ChildInvocationObserver& lhs, const ChildInvocationObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API RemoteObserver : virtual public ChildInvocationObserver
{
public:
 
    typedef RemoteObserverPtr PointerType;
 
    virtual ~RemoteObserver();
 
#ifdef ICE_CPP11_COMPILER
    RemoteObserver() = default;
    RemoteObserver(const RemoteObserver&) = default;
    RemoteObserver& operator=(const RemoteObserver&) = default;
#endif
};
 
inline bool operator==(const RemoteObserver& lhs, const RemoteObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const RemoteObserver& lhs, const RemoteObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API CollocatedObserver : virtual public ChildInvocationObserver
{
public:
 
    typedef CollocatedObserverPtr PointerType;
 
    virtual ~CollocatedObserver();
 
#ifdef ICE_CPP11_COMPILER
    CollocatedObserver() = default;
    CollocatedObserver(const CollocatedObserver&) = default;
    CollocatedObserver& operator=(const CollocatedObserver&) = default;
#endif
};
 
inline bool operator==(const CollocatedObserver& lhs, const CollocatedObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const CollocatedObserver& lhs, const CollocatedObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API InvocationObserver : virtual public Observer
{
public:
 
    typedef InvocationObserverPtr PointerType;
 
    virtual ~InvocationObserver();
 
#ifdef ICE_CPP11_COMPILER
    InvocationObserver() = default;
    InvocationObserver(const InvocationObserver&) = default;
    InvocationObserver& operator=(const InvocationObserver&) = default;
#endif
 
    virtual void retried() = 0;
 
    virtual void userException() = 0;
 
    virtual RemoteObserverPtr getRemoteObserver(const ::Ice::ConnectionInfoPtr& con, const ::Ice::EndpointPtr& endpt, ::Ice::Int requestId, ::Ice::Int size) = 0;
 
    virtual CollocatedObserverPtr getCollocatedObserver(const ::Ice::ObjectAdapterPtr& adapter, ::Ice::Int requestId, ::Ice::Int size) = 0;
};
 
inline bool operator==(const InvocationObserver& lhs, const InvocationObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const InvocationObserver& lhs, const InvocationObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
class ICE_API ObserverUpdater : public virtual ::Ice::LocalObject
{
public:
 
    typedef ObserverUpdaterPtr PointerType;
 
    virtual ~ObserverUpdater();
 
#ifdef ICE_CPP11_COMPILER
    ObserverUpdater() = default;
    ObserverUpdater(const ObserverUpdater&) = default;
    ObserverUpdater& operator=(const ObserverUpdater&) = default;
#endif
 
    virtual void updateConnectionObservers() = 0;
 
    virtual void updateThreadObservers() = 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 ICE_API CommunicatorObserver : public virtual ::Ice::LocalObject
{
public:
 
    typedef CommunicatorObserverPtr PointerType;
 
    virtual ~CommunicatorObserver();
 
#ifdef ICE_CPP11_COMPILER
    CommunicatorObserver() = default;
    CommunicatorObserver(const CommunicatorObserver&) = default;
    CommunicatorObserver& operator=(const CommunicatorObserver&) = default;
#endif
 
    virtual ObserverPtr getConnectionEstablishmentObserver(const ::Ice::EndpointPtr& endpt, const ::std::string& connector) = 0;
 
    virtual ObserverPtr getEndpointLookupObserver(const ::Ice::EndpointPtr& endpt) = 0;
 
    virtual ConnectionObserverPtr getConnectionObserver(const ::Ice::ConnectionInfoPtr& c, const ::Ice::EndpointPtr& e, ConnectionState s, const ConnectionObserverPtr& o) = 0;
 
    virtual ThreadObserverPtr getThreadObserver(const ::std::string& parent, const ::std::string& id, ThreadState s, const ThreadObserverPtr& o) = 0;
 
    virtual InvocationObserverPtr getInvocationObserver(const ::Ice::ObjectPrx& prx, const ::std::string& operation, const ::Ice::Context& ctx) = 0;
 
    virtual DispatchObserverPtr getDispatchObserver(const ::Ice::Current& c, ::Ice::Int size) = 0;
 
    virtual void setObserverUpdater(const ObserverUpdaterPtr& updater) = 0;
};
 
inline bool operator==(const CommunicatorObserver& lhs, const CommunicatorObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) == static_cast<const ::Ice::LocalObject&>(rhs);
}
 
inline bool operator<(const CommunicatorObserver& lhs, const CommunicatorObserver& rhs)
{
    return static_cast<const ::Ice::LocalObject&>(lhs) < static_cast<const ::Ice::LocalObject&>(rhs);
}
 
}
 
}
 
namespace Ice
{
 
}
 
#endif
 
#include <IceUtil/PopDisableWarnings.h>
#endif