zeroc-ice 3.6b1

data/ext/ice/cpp/include/Ice/IncomingAsync.h

@@ -0,0 +1,108 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#ifndef ICE_INCOMING_ASYNC_H
+#define ICE_INCOMING_ASYNC_H
+
+#include <Ice/IncomingAsyncF.h>
+#include <Ice/Incoming.h>
+
+namespace Ice
+{
+
+class ICE_API AMDCallback : virtual public Ice::LocalObject
+{
+public:
+
+    virtual void ice_exception(const ::std::exception&) = 0;
+    virtual void ice_exception() = 0;
+};
+
+}
+
+namespace IceInternal
+{
+
+//
+// We need virtual inheritance from AMDCallback, because we use multiple
+// inheritance from Ice::AMDCallback for generated AMD code.
+//
+class ICE_API IncomingAsync : public IncomingBase, virtual public Ice::AMDCallback
+{
+public:
+
+    IncomingAsync(Incoming&); // Adopts the argument. It must not be used afterwards.
+
+    void __deactivate(Incoming&);
+
+    virtual void ice_exception(const ::std::exception&);
+    virtual void ice_exception();
+
+protected:
+
+    void __response();
+    void __exception(const std::exception&);
+    void __exception();
+
+    bool __validateResponse(bool);
+
+private:
+
+    //
+    // We need a separate InstancePtr, because _is and _os only hold a
+    // Instance* for optimization.
+    //
+    const InstancePtr _instanceCopy;
+
+    //
+    // We need a separate ConnectionIPtr, because IncomingBase only
+    // holds a ConnectionI* for optimization.
+    //
+    const ResponseHandlerPtr _responseHandlerCopy;
+
+    const bool _retriable;
+    bool _active;
+};
+
+}
+
+namespace Ice
+{
+
+class ICE_API AMD_Object_ice_invoke : virtual public Ice::AMDCallback
+{
+public:
+    
+    virtual void ice_response(bool, const std::vector<Ice::Byte>&) = 0;
+    virtual void ice_response(bool, const std::pair<const Ice::Byte*, const Ice::Byte*>&) = 0;
+};
+
+}
+
+namespace IceAsync
+{
+
+namespace Ice
+{
+
+class ICE_API AMD_Object_ice_invoke : public ::Ice::AMD_Object_ice_invoke, public IceInternal::IncomingAsync
+{
+public:
+    
+    AMD_Object_ice_invoke(IceInternal::Incoming&);
+    
+    virtual void ice_response(bool, const std::vector< ::Ice::Byte>&);
+    virtual void ice_response(bool, const std::pair<const ::Ice::Byte*, const ::Ice::Byte*>&);
+};
+
+}
+
+}
+
+#endif

data/ext/ice/cpp/include/Ice/IncomingAsyncF.h

@@ -0,0 +1,35 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#ifndef ICE_INCOMING_ASYNC_F_H
+#define ICE_INCOMING_ASYNC_F_H
+
+#include <IceUtil/Shared.h>
+
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class IncomingAsync;
+ICE_API IceUtil::Shared* upCast(IncomingAsync*);
+typedef IceInternal::Handle<IncomingAsync> IncomingAsyncPtr;
+
+}
+
+namespace Ice
+{
+
+class AMD_Object_ice_invoke;
+ICE_API IceUtil::Shared* upCast(::Ice::AMD_Object_ice_invoke*);
+typedef IceInternal::Handle<AMD_Object_ice_invoke> AMD_Object_ice_invokePtr;
+
+}
+
+#endif

data/ext/ice/cpp/include/Ice/Initialize.h

@@ -0,0 +1,141 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2015 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.
+//
+// **********************************************************************
+
+#ifndef ICE_INITIALIZE_H
+#define ICE_INITIALIZE_H
+
+#include <IceUtil/Timer.h>
+#include <Ice/CommunicatorF.h>
+#include <Ice/PropertiesF.h>
+#include <Ice/InstanceF.h>
+#include <Ice/LoggerF.h>
+#include <Ice/StreamF.h>
+#include <Ice/InstrumentationF.h>
+#include <Ice/Dispatcher.h>
+#include <Ice/FactoryTable.h>
+#include <Ice/BuiltinSequences.h>
+#include <Ice/Version.h>
+#include <Ice/Plugin.h>
+
+namespace Ice
+{
+
+ICE_API StringSeq argsToStringSeq(int, char*[]);
+
+#ifdef _WIN32
+
+ICE_API StringSeq argsToStringSeq(int, wchar_t*[]);
+
+#endif
+
+//
+// This function assumes that the string sequence only contains
+// elements of the argument vector. The function shifts the
+// the argument vector elements so that the vector matches the
+// contents of the sequence.
+//
+ICE_API void stringSeqToArgs(const StringSeq&, int&, char*[]);
+
+ICE_API PropertiesPtr createProperties();
+ICE_API PropertiesPtr createProperties(StringSeq&, const PropertiesPtr& = 0);
+ICE_API PropertiesPtr createProperties(int&, char*[], const PropertiesPtr& = 0);
+
+//
+// This class is used to notify user of when Ice threads are started
+// and stopped.
+//
+class ICE_API ThreadNotification : public IceUtil::Shared
+{
+public:
+
+    virtual void start() = 0;
+    virtual void stop() = 0;
+};
+
+typedef IceUtil::Handle<ThreadNotification> ThreadNotificationPtr;
+
+//
+// A special plug-in that installs thread hook during a communicator's initialization.
+// Both initialize and destroy are no-op. See Ice::InitializationData.
+//
+class ICE_API ThreadHookPlugin : public Ice::Plugin
+{
+public:
+
+    ThreadHookPlugin(const CommunicatorPtr& communicator, const ThreadNotificationPtr&);
+
+    virtual void initialize();
+
+    virtual void destroy();
+};
+
+//
+// Communicator initialization info
+//
+struct InitializationData
+{
+    PropertiesPtr properties;
+    LoggerPtr logger;
+    Instrumentation::CommunicatorObserverPtr observer;
+    ThreadNotificationPtr threadHook;
+    DispatcherPtr dispatcher;
+    CompactIdResolverPtr compactIdResolver;
+};
+
+ICE_API CommunicatorPtr initialize(int&, char*[], const InitializationData& = InitializationData(),
+                                   Int = ICE_INT_VERSION);
+
+ICE_API CommunicatorPtr initialize(Ice::StringSeq&, const InitializationData& = InitializationData(),
+                                   Int = ICE_INT_VERSION);
+
+ICE_API CommunicatorPtr initialize(const InitializationData& = InitializationData(), 
+                                   Int = ICE_INT_VERSION);
+
+
+ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
+ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&,
+                                         const EncodingVersion&);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&, const ::std::vector< Byte >&, const EncodingVersion&);
+ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
+                                         const ::std::pair< const Ice::Byte*, const Ice::Byte*>&);
+ICE_API InputStreamPtr createInputStream(const CommunicatorPtr&,
+                                         const ::std::pair< const Ice::Byte*, const Ice::Byte*>&,
+                                         const EncodingVersion&);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&,
+                                       const ::std::pair< const Ice::Byte*, const Ice::Byte*>&);
+ICE_API InputStreamPtr wrapInputStream(const CommunicatorPtr&,
+                                       const ::std::pair< const Ice::Byte*, const Ice::Byte*>&, 
+                                       const EncodingVersion&);
+
+ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&);
+ICE_API OutputStreamPtr createOutputStream(const CommunicatorPtr&, const EncodingVersion&);
+
+ICE_API LoggerPtr getProcessLogger();
+ICE_API void setProcessLogger(const LoggerPtr&);
+
+typedef Ice::Plugin* (*PLUGIN_FACTORY)(const ::Ice::CommunicatorPtr&, const std::string&, const ::Ice::StringSeq&);
+ICE_API void registerPluginFactory(const std::string&, PLUGIN_FACTORY, bool);
+
+}
+
+namespace IceInternal
+{
+
+//
+// Some Ice extensions need access to the Ice internal instance. Do
+// not use this operation for regular application code! It is intended
+// to be used by modules such as Freeze.
+//
+ICE_API InstancePtr getInstance(const ::Ice::CommunicatorPtr&);
+ICE_API IceUtil::TimerPtr getInstanceTimer(const ::Ice::CommunicatorPtr&);
+
+}
+
+#endif

data/ext/ice/cpp/include/Ice/InstanceF.h

@@ -0,0 +1,26 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.
+//
+// **********************************************************************
+
+#ifndef ICE_INSTANCE_F_H
+#define ICE_INSTANCE_F_H
+
+#include <IceUtil/Shared.h>
+
+#include <Ice/Handle.h>
+
+namespace IceInternal
+{
+
+class Instance;
+ICE_API IceUtil::Shared* upCast(Instance*);
+typedef IceInternal::Handle<Instance> InstancePtr;
+
+}
+
+#endif

data/ext/ice/cpp/include/Ice/Instrumentation.h

@@ -0,0 +1,377 @@
+// **********************************************************************
+//
+// Copyright (c) 2003-2014 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.6b
+//
+// <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/Exception.h>
+#include <Ice/LocalObject.h>
+#include <Ice/StreamHelpers.h>
+#include <IceUtil/ScopedArray.h>
+#include <IceUtil/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  != 30651
+#       error Ice version mismatch: an exact match is required for beta generated code
+#   endif
+#endif
+
+#ifndef ICE_API
+#   ifdef ICE_API_EXPORTS
+#       define ICE_API ICE_DECLSPEC_EXPORT
+#   else
+#       define ICE_API ICE_DECLSPEC_IMPORT
+#   endif
+#endif
+
+namespace Ice
+{
+
+namespace Instrumentation
+{
+
+class Observer;
+bool operator==(const Observer&, const Observer&);
+bool operator<(const Observer&, const Observer&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::Observer*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::Observer> ObserverPtr;
+
+class ThreadObserver;
+bool operator==(const ThreadObserver&, const ThreadObserver&);
+bool operator<(const ThreadObserver&, const ThreadObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::ThreadObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::ThreadObserver> ThreadObserverPtr;
+
+class ConnectionObserver;
+bool operator==(const ConnectionObserver&, const ConnectionObserver&);
+bool operator<(const ConnectionObserver&, const ConnectionObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::ConnectionObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::ConnectionObserver> ConnectionObserverPtr;
+
+class DispatchObserver;
+bool operator==(const DispatchObserver&, const DispatchObserver&);
+bool operator<(const DispatchObserver&, const DispatchObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::DispatchObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::DispatchObserver> DispatchObserverPtr;
+
+class ChildInvocationObserver;
+bool operator==(const ChildInvocationObserver&, const ChildInvocationObserver&);
+bool operator<(const ChildInvocationObserver&, const ChildInvocationObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::ChildInvocationObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::ChildInvocationObserver> ChildInvocationObserverPtr;
+
+class RemoteObserver;
+bool operator==(const RemoteObserver&, const RemoteObserver&);
+bool operator<(const RemoteObserver&, const RemoteObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::RemoteObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::RemoteObserver> RemoteObserverPtr;
+
+class CollocatedObserver;
+bool operator==(const CollocatedObserver&, const CollocatedObserver&);
+bool operator<(const CollocatedObserver&, const CollocatedObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::CollocatedObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::CollocatedObserver> CollocatedObserverPtr;
+
+class InvocationObserver;
+bool operator==(const InvocationObserver&, const InvocationObserver&);
+bool operator<(const InvocationObserver&, const InvocationObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::InvocationObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::InvocationObserver> InvocationObserverPtr;
+
+class ObserverUpdater;
+bool operator==(const ObserverUpdater&, const ObserverUpdater&);
+bool operator<(const ObserverUpdater&, const ObserverUpdater&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::ObserverUpdater*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::ObserverUpdater> ObserverUpdaterPtr;
+
+class CommunicatorObserver;
+bool operator==(const CommunicatorObserver&, const CommunicatorObserver&);
+bool operator<(const CommunicatorObserver&, const CommunicatorObserver&);
+ICE_API ::Ice::LocalObject* upCast(::Ice::Instrumentation::CommunicatorObserver*);
+typedef ::IceInternal::Handle< ::Ice::Instrumentation::CommunicatorObserver> CommunicatorObserverPtr;
+
+}
+
+}
+
+namespace Ice
+{
+
+namespace Instrumentation
+{
+
+enum ThreadState
+{
+    ThreadStateIdle,
+    ThreadStateInUseForIO,
+    ThreadStateInUseForUser,
+    ThreadStateInUseForOther
+};
+
+enum ConnectionState
+{
+    ConnectionStateValidating,
+    ConnectionStateHolding,
+    ConnectionStateActive,
+    ConnectionStateClosing,
+    ConnectionStateClosed
+};
+
+}
+
+}
+
+namespace Ice
+{
+}
+
+namespace Ice
+{
+
+namespace Instrumentation
+{
+
+class ICE_API Observer : virtual public ::Ice::LocalObject
+{
+public:
+
+    typedef ObserverPtr PointerType;
+
+    virtual void attach() = 0;
+
+    virtual void detach() = 0;
+
+    virtual void failed(const ::std::string&) = 0;
+};
+
+inline bool operator==(const Observer& l, const Observer& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const Observer& l, const Observer& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API ThreadObserver : virtual public ::Ice::Instrumentation::Observer
+{
+public:
+
+    typedef ThreadObserverPtr PointerType;
+
+    virtual void stateChanged(::Ice::Instrumentation::ThreadState, ::Ice::Instrumentation::ThreadState) = 0;
+};
+
+inline bool operator==(const ThreadObserver& l, const ThreadObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const ThreadObserver& l, const ThreadObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API ConnectionObserver : virtual public ::Ice::Instrumentation::Observer
+{
+public:
+
+    typedef ConnectionObserverPtr PointerType;
+
+    virtual void sentBytes(::Ice::Int) = 0;
+
+    virtual void receivedBytes(::Ice::Int) = 0;
+};
+
+inline bool operator==(const ConnectionObserver& l, const ConnectionObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const ConnectionObserver& l, const ConnectionObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API DispatchObserver : virtual public ::Ice::Instrumentation::Observer
+{
+public:
+
+    typedef DispatchObserverPtr PointerType;
+
+    virtual void userException() = 0;
+
+    virtual void reply(::Ice::Int) = 0;
+};
+
+inline bool operator==(const DispatchObserver& l, const DispatchObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const DispatchObserver& l, const DispatchObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API ChildInvocationObserver : virtual public ::Ice::Instrumentation::Observer
+{
+public:
+
+    typedef ChildInvocationObserverPtr PointerType;
+
+    virtual void reply(::Ice::Int) = 0;
+};
+
+inline bool operator==(const ChildInvocationObserver& l, const ChildInvocationObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const ChildInvocationObserver& l, const ChildInvocationObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API RemoteObserver : virtual public ::Ice::Instrumentation::ChildInvocationObserver
+{
+public:
+
+    typedef RemoteObserverPtr PointerType;
+};
+
+inline bool operator==(const RemoteObserver& l, const RemoteObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const RemoteObserver& l, const RemoteObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API CollocatedObserver : virtual public ::Ice::Instrumentation::ChildInvocationObserver
+{
+public:
+
+    typedef CollocatedObserverPtr PointerType;
+};
+
+inline bool operator==(const CollocatedObserver& l, const CollocatedObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const CollocatedObserver& l, const CollocatedObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API InvocationObserver : virtual public ::Ice::Instrumentation::Observer
+{
+public:
+
+    typedef InvocationObserverPtr PointerType;
+
+    virtual void retried() = 0;
+
+    virtual void userException() = 0;
+
+    virtual ::Ice::Instrumentation::RemoteObserverPtr getRemoteObserver(const ::Ice::ConnectionInfoPtr&, const ::Ice::EndpointPtr&, ::Ice::Int, ::Ice::Int) = 0;
+
+    virtual ::Ice::Instrumentation::CollocatedObserverPtr getCollocatedObserver(const ::Ice::ObjectAdapterPtr&, ::Ice::Int, ::Ice::Int) = 0;
+};
+
+inline bool operator==(const InvocationObserver& l, const InvocationObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const InvocationObserver& l, const InvocationObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API ObserverUpdater : virtual public ::Ice::LocalObject
+{
+public:
+
+    typedef ObserverUpdaterPtr PointerType;
+
+    virtual void updateConnectionObservers() = 0;
+
+    virtual void updateThreadObservers() = 0;
+};
+
+inline bool operator==(const ObserverUpdater& l, const ObserverUpdater& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const ObserverUpdater& l, const ObserverUpdater& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+class ICE_API CommunicatorObserver : virtual public ::Ice::LocalObject
+{
+public:
+
+    typedef CommunicatorObserverPtr PointerType;
+
+    virtual ::Ice::Instrumentation::ObserverPtr getConnectionEstablishmentObserver(const ::Ice::EndpointPtr&, const ::std::string&) = 0;
+
+    virtual ::Ice::Instrumentation::ObserverPtr getEndpointLookupObserver(const ::Ice::EndpointPtr&) = 0;
+
+    virtual ::Ice::Instrumentation::ConnectionObserverPtr getConnectionObserver(const ::Ice::ConnectionInfoPtr&, const ::Ice::EndpointPtr&, ::Ice::Instrumentation::ConnectionState, const ::Ice::Instrumentation::ConnectionObserverPtr&) = 0;
+
+    virtual ::Ice::Instrumentation::ThreadObserverPtr getThreadObserver(const ::std::string&, const ::std::string&, ::Ice::Instrumentation::ThreadState, const ::Ice::Instrumentation::ThreadObserverPtr&) = 0;
+
+    virtual ::Ice::Instrumentation::InvocationObserverPtr getInvocationObserver(const ::Ice::ObjectPrx&, const ::std::string&, const ::Ice::Context&) = 0;
+
+    virtual ::Ice::Instrumentation::DispatchObserverPtr getDispatchObserver(const ::Ice::Current&, ::Ice::Int) = 0;
+
+    virtual void setObserverUpdater(const ::Ice::Instrumentation::ObserverUpdaterPtr&) = 0;
+};
+
+inline bool operator==(const CommunicatorObserver& l, const CommunicatorObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) == static_cast<const ::Ice::LocalObject&>(r);
+}
+
+inline bool operator<(const CommunicatorObserver& l, const CommunicatorObserver& r)
+{
+    return static_cast<const ::Ice::LocalObject&>(l) < static_cast<const ::Ice::LocalObject&>(r);
+}
+
+}
+
+}
+
+#include <IceUtil/PopDisableWarnings.h>
+#endif