zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/include/Ice/CommunicatorAsync.h

@@ -1,154 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_COMMUNICATOR_ASYNC_H
-#define ICE_COMMUNICATOR_ASYNC_H
-
-#ifndef ICE_CPP11_MAPPING
-
-#include <Ice/Communicator.h>
-
-namespace Ice
-{
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- * \headerfile Ice/Ice.h
- */
-template<class T>
-class CallbackNC_Communicator_flushBatchRequests : public Callback_Communicator_flushBatchRequests_Base,
-                                                   public ::IceInternal::OnewayCallbackNC<T>
-{
-public:
-
-    typedef IceUtil::Handle<T> TPtr;
-
-    typedef void (T::*Exception)(const ::Ice::Exception&);
-    typedef void (T::*Sent)(bool);
-
-    CallbackNC_Communicator_flushBatchRequests(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallbackNC<T>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        ::Ice::CommunicatorPtr communicator = result->getCommunicator();
-        assert(communicator);
-        try
-        {
-            communicator->end_flushBatchRequests(result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::CallbackNC<T>::exception(result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Communicator::begin_flushBatchRequests.
- */
-template<class T> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(const IceUtil::Handle<T>& instance,
-                                            void (T::*excb)(const ::Ice::Exception&),
-                                            void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Communicator_flushBatchRequests<T>(instance, excb, sentcb);
-}
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Communicator::begin_flushBatchRequests.
- */
-template<class T> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const ::Ice::Exception&),
-                                            void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Communicator_flushBatchRequests<T>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- * \headerfile Ice/Ice.h
- */
-template<class T, typename CT>
-class Callback_Communicator_flushBatchRequests : public Callback_Communicator_flushBatchRequests_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&);
-
-    Callback_Communicator_flushBatchRequests(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallback<T, CT>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        ::Ice::CommunicatorPtr communicator = result->getCommunicator();
-        assert(communicator);
-        try
-        {
-            communicator->end_flushBatchRequests(result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::Callback<T, CT>::exception(result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- */
-template<class T, typename CT> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(const IceUtil::Handle<T>& instance,
-                                            void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                            void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Communicator_flushBatchRequests<T, CT>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Communicator::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Communicator_flushBatchRequests.
- */
-template<class T, typename CT> Callback_Communicator_flushBatchRequestsPtr
-newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                            void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Communicator_flushBatchRequests<T, CT>(instance, excb, sentcb);
-}
-
-}
-#endif
-
-#endif

data/dist/ice/cpp/include/Ice/Comparable.h

@@ -1,205 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_COMPARABLE_H
-#define ICE_COMPARABLE_H
-
-#include <functional>
-
-namespace Ice
-{
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the contents are equal, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetEqualTo(const T& lhs, const U& rhs)
-{
-    if(lhs && rhs)
-    {
-        return *lhs == *rhs;
-    }
-    else
-    {
-        return !lhs && !rhs;
-    }
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetLess(const T& lhs, const U& rhs)
-{
-    if(lhs && rhs)
-    {
-        return *lhs < *rhs;
-    }
-    else
-    {
-        return !lhs && rhs;
-    }
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetGreater(const T& lhs, const U& rhs)
-{
-    return targetLess(rhs, lhs);
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than or equal to the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetLessEqual(const T& lhs, const U& rhs)
-{
-    return !targetGreater(lhs, rhs);
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than or equal to the right-hand side, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetGreaterEqual(const T& lhs, const U& rhs)
-{
-    return !targetLess(lhs, rhs);
-}
-
-/**
- * Compares the contents of two smart pointers.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the contents are not equal, false otherwise.
- */
-template<typename T, typename U>
-inline bool targetNotEqualTo(const T& lhs, const U& rhs)
-{
-    return !targetEqualTo(lhs, rhs);
-}
-
-#ifdef ICE_CPP11_MAPPING
-
-/**
- * Functor class that compares the contents of two smart pointers of the given type using the given comparator.
- * \headerfile Ice/Ice.h
- */
-template<typename T, template<typename> class Compare>
-struct TargetCompare
-{
-    /**
-     * Executes the functor to compare the contents of two smart pointers.
-     * @return True if the contents satisfy the given comparator, false otherwise.
-     */
-    bool operator()(const T& lhs, const T& rhs) const
-    {
-        if(lhs && rhs)
-        {
-            return Compare<typename T::element_type>()(*lhs, *rhs);
-        }
-        else
-        {
-            return Compare<bool>()(static_cast<const bool>(lhs), static_cast<const bool>(rhs));
-        }
-    }
-};
-
-//
-// Relational operators for generated structs and classes
-//
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator<(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() < rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares less than or equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator<=(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() <= rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator>(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() > rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares greater than or equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator>=(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() >= rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side compares equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator==(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() == rhs.ice_tuple();
-}
-
-/**
- * Relational operator for generated structs and classes.
- * @param lhs The left-hand side.
- * @param rhs The right-hand side.
- * @return True if the left-hand side is not equal to the right-hand side, false otherwise.
- */
-template<class C, typename = std::enable_if<std::is_member_function_pointer<decltype(&C::ice_tuple)>::value>>
-bool operator!=(const C& lhs, const C& rhs)
-{
-   return lhs.ice_tuple() != rhs.ice_tuple();
-}
-
-#endif
-
-}
-
-#endif

data/dist/ice/cpp/include/Ice/ConnectionAsync.h

@@ -1,302 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_CONNECTION_ASYNC_H
-#define ICE_CONNECTION_ASYNC_H
-
-#ifndef ICE_CPP11_MAPPING
-
-#include <Ice/Connection.h>
-#include <Ice/Proxy.h>
-
-namespace Ice
-{
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Connection::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Connection_flushBatchRequests.
- * \headerfile Ice/Ice.h
- */
-template<class T>
-class CallbackNC_Connection_flushBatchRequests : public Callback_Connection_flushBatchRequests_Base,
-                                                 public ::IceInternal::OnewayCallbackNC<T>
-{
-public:
-
-    typedef IceUtil::Handle<T> TPtr;
-
-    typedef void (T::*Exception)(const ::Ice::Exception&);
-    typedef void (T::*Sent)(bool);
-
-    CallbackNC_Connection_flushBatchRequests(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallbackNC<T>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        ::Ice::ConnectionPtr connection = result->getConnection();
-        assert(connection);
-        try
-        {
-            connection->end_flushBatchRequests(result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::CallbackNC<T>::exception(result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_flushBatchRequests.
- */
-template<class T> Callback_Connection_flushBatchRequestsPtr
-newCallback_Connection_flushBatchRequests(const IceUtil::Handle<T>& instance,
-                                          void (T::*excb)(const ::Ice::Exception&),
-                                          void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Connection_flushBatchRequests<T>(instance, excb, sentcb);
-}
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_flushBatchRequests.
- */
-template<class T> Callback_Connection_flushBatchRequestsPtr
-newCallback_Connection_flushBatchRequests(T* instance, void (T::*excb)(const ::Ice::Exception&),
-                                          void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Connection_flushBatchRequests<T>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Connection::begin_flushBatchRequests.
- * Create a wrapper instance by calling ::Ice::newCallback_Connection_flushBatchRequests.
- * \headerfile Ice/Ice.h
- */
-template<class T, typename CT>
-class Callback_Connection_flushBatchRequests : public Callback_Connection_flushBatchRequests_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&);
-
-    Callback_Connection_flushBatchRequests(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallback<T, CT>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& result) const
-    {
-        ::Ice::ConnectionPtr connection = result->getConnection();
-        assert(connection);
-        try
-        {
-            connection->end_flushBatchRequests(result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::Callback<T, CT>::exception(result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_flushBatchRequests.
- */
-template<class T, typename CT> Callback_Connection_flushBatchRequestsPtr
-newCallback_Connection_flushBatchRequests(const IceUtil::Handle<T>& instance,
-                                          void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                          void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Connection_flushBatchRequests<T, CT>(instance, excb, sentcb);
-}
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_flushBatchRequests.
- */
-template<class T, typename CT> Callback_Connection_flushBatchRequestsPtr
-newCallback_Connection_flushBatchRequests(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                          void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Connection_flushBatchRequests<T, CT>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Connection::begin_heartbeat.
- * Create a wrapper instance by calling ::Ice::newCallback_Connection_heartbeat.
- * \headerfile Ice/Ice.h
- */
-template<class T>
-class CallbackNC_Connection_heartbeat : public Callback_Connection_heartbeat_Base,
-                                        public ::IceInternal::OnewayCallbackNC<T>
-{
-public:
-
-    typedef IceUtil::Handle<T> TPtr;
-
-    typedef void (T::*Exception)(const ::Ice::Exception&);
-    typedef void (T::*Sent)(bool);
-
-    CallbackNC_Connection_heartbeat(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallbackNC<T>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-    {
-        ::Ice::ConnectionPtr __con = __result->getConnection();
-        assert(__con);
-        try
-        {
-            __con->end_heartbeat(__result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::CallbackNC<T>::exception(__result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_heartbeat.
- */
-template<class T> Callback_Connection_heartbeatPtr
-newCallback_Connection_heartbeat(const IceUtil::Handle<T>& instance,
-                                 void (T::*excb)(const ::Ice::Exception&),
-                                 void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Connection_heartbeat<T>(instance, excb, sentcb);
-}
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_heartbeat.
- */
-template<class T> Callback_Connection_heartbeatPtr
-newCallback_Connection_heartbeat(T* instance, void (T::*excb)(const ::Ice::Exception&), void (T::*sentcb)(bool) = 0)
-{
-    return new CallbackNC_Connection_heartbeat<T>(instance, excb, sentcb);
-}
-
-/**
- * Type-safe asynchronous callback wrapper class used for calls to
- * Ice::Connection::begin_heartbeat.
- * Create a wrapper instance by calling ::Ice::newCallback_Connection_heartbeat.
- * \headerfile Ice/Ice.h
- */
-template<class T, typename CT>
-class Callback_Connection_heartbeat : public Callback_Connection_heartbeat_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&);
-
-    Callback_Connection_heartbeat(const TPtr& obj, Exception excb, Sent sentcb)
-        : ::IceInternal::OnewayCallback<T, CT>(obj, 0, excb, sentcb)
-    {
-    }
-
-    /// \cond INTERNAL
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
-    {
-        ::Ice::ConnectionPtr __con = __result->getConnection();
-        assert(__con);
-        try
-        {
-            __con->end_heartbeat(__result);
-            assert(false);
-        }
-        catch(const ::Ice::Exception& ex)
-        {
-            ::IceInternal::Callback<T, CT>::exception(__result, ex);
-        }
-    }
-    /// \endcond
-};
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_heartbeat.
- */
-template<class T, typename CT> Callback_Connection_heartbeatPtr
-newCallback_Connection_heartbeat(const IceUtil::Handle<T>& instance,
-                                 void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                 void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Connection_heartbeat<T, CT>(instance, excb, sentcb);
-}
-
-/**
- * Creates a callback wrapper instance that delegates to your object.
- * @param instance The callback object.
- * @param excb The exception method of the callback object.
- * @param sentcb The sent method of the callback object.
- * @return An object that can be passed to an asynchronous invocation of
- * Ice::Connection::begin_heartbeat.
- */
-template<class T, typename CT> Callback_Connection_heartbeatPtr
-newCallback_Connection_heartbeat(T* instance, void (T::*excb)(const ::Ice::Exception&, const CT&),
-                                 void (T::*sentcb)(bool, const CT&) = 0)
-{
-    return new Callback_Connection_heartbeat<T, CT>(instance, excb, sentcb);
-}
-
-}
-
-#endif
-#endif

data/dist/ice/cpp/include/Ice/ConsoleUtil.h

@@ -1,23 +0,0 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
-
-#ifndef ICE_CONSOLE_UTIL_H
-#define ICE_CONSOLE_UTIL_H
-
-#include <IceUtil/ConsoleUtil.h>
-
-namespace IceInternal
-{
-
-using IceUtilInternal::consoleOut;
-using IceUtilInternal::consoleErr;
-
-#if defined(_WIN32)
-using IceUtilInternal::endl;
-using IceUtilInternal::flush;
-#endif
-
-}
-
-#endif