zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,17 +1,13 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_ASYNC_RESULT_F_H
 #define ICE_ASYNC_RESULT_F_H
 
-#include <IceUtil/Shared.h>
+#ifndef ICE_CPP11_MAPPING
 
+#include <IceUtil/Shared.h>
 #include <Ice/Handle.h>
 
 namespace Ice
@@ -24,3 +20,4 @@ typedef IceInternal::Handle AsyncResultPtr;
 }
 
 #endif
+#endif

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

@@ -1,25 +1,20 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_BATCH_REQUEST_INTERCEPTOR_H
 #define ICE_BATCH_REQUEST_INTERCEPTOR_H
 
 #include <IceUtil/Shared.h>
-
 #include <Ice/ProxyF.h>
-#ifdef ICE_CPP11
-#   include <functional>
-#endif
 
 namespace Ice
 {
 
+/**
+ * Represents an invocation on a proxy configured for batch-oneway or batch-datagram.
+ * \headerfile Ice/Ice.h
+ */
 class BatchRequest
 {
 public:
@@ -28,25 +23,53 @@ public:
     {
     }
 
+    /**
+     * Queues the request for an eventual flush.
+     */
     virtual void enqueue() const = 0;
+
+    /**
+     * Obtains the size of the request.
+     * @return The number of bytes consumed by the request.
+     */
     virtual int getSize() const = 0;
+
+    /**
+     * Obtains the name of the operation.
+     * @return The operation name.
+     */
     virtual const std::string& getOperation() const = 0;
-    virtual const Ice::ObjectPrx& getProxy() const = 0;
+
+    /**
+     * Obtains the proxy on which the batch request was invoked.
+     * @return The originating proxy.
+     */
+    virtual const Ice::ObjectPrxPtr& getProxy() const = 0;
 };
 
+#ifndef ICE_CPP11_MAPPING
+
+/**
+ * The base class for a batch request interceptor. Subclasses must implement enqueue.
+ * The interceptor can be installed via InitializationData.
+ * \headerfile Ice/Ice.h
+ */
 class BatchRequestInterceptor : public IceUtil::Shared
 {
 public:
 
-    virtual void enqueue(const BatchRequest&, int, int) = 0;
+    /**
+     * Called by the Ice run time to enqueue a batch request.
+     * @param req An object representing the batch request.
+     * @param count The number of requests currently in the queue.
+     * @param size The number of bytes consumed by the requests currently in the queue.
+     */
+    virtual void enqueue(const BatchRequest& req, int count, int size) = 0;
 };
 typedef IceUtil::Handle<BatchRequestInterceptor> BatchRequestInterceptorPtr;
 
-#ifdef ICE_CPP11
-ICE_API BatchRequestInterceptorPtr
-newBatchRequestInterceptor(const ::std::function<void (const BatchRequest&, int, int)>&);
 #endif
 
-};
+}
 
 #endif

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_BATCH_REQUEST_QUEUE_F_H
 #define ICE_BATCH_REQUEST_QUEUE_F_H

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

@@ -1,11 +1,6 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_BUFFER_H
 #define ICE_BUFFER_H
@@ -21,7 +16,8 @@ public:
 
     Buffer() : i(b.begin()) { }
     Buffer(const Ice::Byte* beg, const Ice::Byte* end) : b(beg, end), i(b.begin()) { }
-    virtual ~Buffer() { }
+    Buffer(const std::vector<Ice::Byte>& v) : b(v), i(b.begin()) { }
+    Buffer(Buffer& o, bool adopt) : b(o.b, adopt), i(b.begin()) { }
 
     void swapBuffer(Buffer&);
 
@@ -43,6 +39,8 @@ public:
 
         Container();
         Container(const_iterator, const_iterator);
+        Container(const std::vector<value_type>&);
+        Container(Container&, bool);
 
         ~Container();
 
@@ -77,13 +75,11 @@ public:
         }
 
         void swap(Container&);
-        
+
         void clear();
 
         void resize(size_type n) // Inlined for performance reasons.
         {
-            assert(!_buf || _capacity > 0);
-
             if(n == 0)
             {
                 clear();
@@ -94,17 +90,15 @@ public:
             }
             _size = n;
         }
-        
+
         void reset()
         {
-            assert(!_buf || _capacity > 0);
-
             if(_size > 0 && _size * 2 < _capacity)
             {
                 //
                 // If the current buffer size is smaller than the
                 // buffer capacity, we shrink the buffer memory to the
-                // current size. This is to avoid holding on too much
+                // current size. This is to avoid holding onto too much
                 // memory if it's not needed anymore.
                 //
                 if(++_shrinkCounter > 2)
@@ -137,7 +131,7 @@ public:
             assert(n < _size);
             return _buf[n];
         }
-        
+
     private:
 
         Container(const Container&);
@@ -148,6 +142,7 @@ public:
         size_type _size;
         size_type _capacity;
         int _shrinkCounter;
+        bool _owned;
     };
 
     Container b;

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

@@ -1,20 +1,23 @@
-// **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// Copyright (c) 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_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>
@@ -31,23 +34,32 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+    /// \cond INTERNAL
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
-        ::Ice::CommunicatorPtr __com = __result->getCommunicator();
-        assert(__com);
+        ::Ice::CommunicatorPtr communicator = result->getCommunicator();
+        assert(communicator);
         try
         {
-            __com->end_flushBatchRequests(__result);
+            communicator->end_flushBatchRequests(result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(__result, 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&),
@@ -56,6 +68,14 @@ newCallback_Communicator_flushBatchRequests(const IceUtil::Handle& instance,
     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)
@@ -63,6 +83,12 @@ newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const :
     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>
@@ -79,22 +105,29 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+    /// \cond INTERNAL
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
-        ::Ice::CommunicatorPtr __com = __result->getCommunicator();
-        assert(__com);
+        ::Ice::CommunicatorPtr communicator = result->getCommunicator();
+        assert(communicator);
         try
         {
-            __com->end_flushBatchRequests(__result);
+            communicator->end_flushBatchRequests(result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(__result, 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&),
@@ -103,6 +136,11 @@ newCallback_Communicator_flushBatchRequests(const IceUtil::Handle& instance,
     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)
@@ -111,5 +149,6 @@ newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const :
 }
 
 }
+#endif
 
 #endif

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

@@ -0,0 +1,205 @@
+//
+// 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