zeroc-ice 3.6.5 → 3.7.0

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

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

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// 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.
@@ -21,7 +21,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 +44,8 @@ public:
 
         Container();
         Container(const_iterator, const_iterator);
+        Container(const std::vector<value_type>&);
+        Container(Container&, bool);
 
         ~Container();
 
@@ -77,13 +80,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 +95,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 +136,7 @@ public:
             assert(n < _size);
             return _buf[n];
         }
-        
+
     private:
 
         Container(const Container&);
@@ -148,6 +147,7 @@ public:
         size_type _size;
         size_type _capacity;
         int _shrinkCounter;
+        bool _owned;
     };
 
     Container b;

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// 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.
@@ -10,6 +10,8 @@
 #ifndef ICE_COMMUNICATOR_ASYNC_H
 #define ICE_COMMUNICATOR_ASYNC_H
 
+#ifndef ICE_CPP11_MAPPING
+
 #include <Ice/Communicator.h>
 
 namespace Ice
@@ -31,23 +33,22 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+    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);
         }
     }
 };
 
-
 template<class T> Callback_Communicator_flushBatchRequestsPtr
 newCallback_Communicator_flushBatchRequests(const IceUtil::Handle<T>& instance,
                                             void (T::*excb)(const ::Ice::Exception&),
@@ -79,18 +80,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+    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);
         }
     }
 };
@@ -111,5 +112,6 @@ newCallback_Communicator_flushBatchRequests(T* instance, void (T::*excb)(const :
 }
 
 }
+#endif
 
 #endif

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

@@ -0,0 +1,130 @@
+// **********************************************************************
+//
+// 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.
+//
+// **********************************************************************
+
+#ifndef ICE_COMPARABLE_H
+#define ICE_COMPARABLE_H
+
+#include <functional>
+
+namespace Ice
+{
+
+template<typename T, typename U>
+inline bool targetEqualTo(const T& lhs, const U& rhs)
+{
+    if(lhs && rhs)
+    {
+        return *lhs == *rhs;
+    }
+    else
+    {
+        return !lhs && !rhs;
+    }
+}
+
+template<typename T, typename U>
+inline bool targetLess(const T& lhs, const U& rhs)
+{
+    if(lhs && rhs)
+    {
+        return *lhs < *rhs;
+    }
+    else
+    {
+        return !lhs && rhs;
+    }
+}
+
+template<typename T, typename U>
+inline bool targetGreater(const T& lhs, const U& rhs)
+{
+    return targetLess(rhs, lhs);
+}
+
+template<typename T, typename U>
+inline bool targetLessEqual(const T& lhs, const U& rhs)
+{
+    return !targetGreater(lhs, rhs);
+}
+
+template<typename T, typename U>
+inline bool targetGreaterEqual(const T& lhs, const U& rhs)
+{
+    return !targetLess(lhs, rhs);
+}
+
+template<typename T, typename U>
+inline bool targetNotEqualTo(const T& lhs, const U& rhs)
+{
+    return !targetEqualTo(lhs, rhs);
+}
+
+#ifdef ICE_CPP11_MAPPING
+
+template<typename T, template<typename> class Compare>
+struct TargetCompare
+{
+    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
+//
+
+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();
+}
+
+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();
+}
+
+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();
+}
+
+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();
+}
+
+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();
+}
+
+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/ext/ice/cpp/include/Ice/Config.h

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// 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.
@@ -22,7 +22,7 @@
 #include <vector>
 #include <map>
 
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
 #   if defined(_WIN32)
 #      include <process.h>
 #   else
@@ -31,24 +31,6 @@
 #   endif
 #endif
 
-//
-// Automatically link Ice[D].lib with Visual C++
-//
-
-#if !defined(ICE_BUILDING_ICE) && defined(ICE_API_EXPORTS)
-#   define ICE_BUILDING_ICE
-#endif
-
-#if defined(_MSC_VER)
-#   if !defined(ICE_BUILDING_ICE)
-#      if defined(_DEBUG) && !defined(ICE_OS_WINRT)
-#          pragma comment(lib, "IceD.lib")
-#      else
-#          pragma comment(lib, "Ice.lib")
-#      endif
-#   endif
-#endif
-
 //
 // Define the Ice and IceInternal namespace, so that we can use the following
 // everywhere in our code:
@@ -64,23 +46,17 @@ namespace IceInternal
 {
 }
 
-#ifndef ICE_API
-#   ifdef ICE_API_EXPORTS
-#       define ICE_API ICE_DECLSPEC_EXPORT
-#   elif defined(ICE_STATIC_LIBS)
-#       define ICE_API /**/
-#   else
-#       define ICE_API ICE_DECLSPEC_IMPORT
-#   endif
-#endif
-
 namespace Ice
 {
 
 typedef unsigned char Byte;
 typedef short Short;
 typedef int Int;
+#ifdef ICE_CPP11_MAPPING
+typedef long long int Long;
+#else
 typedef IceUtil::Int64 Long;
+#endif
 typedef float Float;
 typedef double Double;
 
@@ -89,12 +65,7 @@ typedef double Double;
 namespace IceInternal
 {
 
-// TODO: Should not be inline, this is not performance critical.
-#ifdef _WIN32
-inline int getSystemErrno() { return GetLastError(); }
-#else
-inline int getSystemErrno() { return errno; }
-#endif
+ICE_API int getSystemErrno();
 
 }
 

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

@@ -1,6 +1,6 @@
 // **********************************************************************
 //
-// Copyright (c) 2003-2018 ZeroC, Inc. All rights reserved.
+// 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.
@@ -10,6 +10,8 @@
 #ifndef ICE_CONNECTION_ASYNC_H
 #define ICE_CONNECTION_ASYNC_H
 
+#ifndef ICE_CPP11_MAPPING
+
 #include <Ice/Connection.h>
 #include <Ice/Proxy.h>
 
@@ -32,18 +34,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
-        ::Ice::ConnectionPtr __con = __result->getConnection();
-        assert(__con);
+        ::Ice::ConnectionPtr connection = result->getConnection();
+        assert(connection);
         try
         {
-            __con->end_flushBatchRequests(__result);
+            connection->end_flushBatchRequests(result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::CallbackNC<T>::exception(__result, ex);
+            ::IceInternal::CallbackNC<T>::exception(result, ex);
         }
     }
 };
@@ -79,18 +81,18 @@ public:
     {
     }
 
-    virtual void completed(const ::Ice::AsyncResultPtr& __result) const
+    virtual void completed(const ::Ice::AsyncResultPtr& result) const
     {
-        ::Ice::ConnectionPtr __con = __result->getConnection();
-        assert(__con);
+        ::Ice::ConnectionPtr connection = result->getConnection();
+        assert(connection);
         try
         {
-            __con->end_flushBatchRequests(__result);
+            connection->end_flushBatchRequests(result);
             assert(false);
         }
         catch(const ::Ice::Exception& ex)
         {
-            ::IceInternal::Callback<T, CT>::exception(__result, ex);
+            ::IceInternal::Callback<T, CT>::exception(result, ex);
         }
     }
 };
@@ -110,6 +112,100 @@ newCallback_Connection_flushBatchRequests(T* instance, void (T::*excb)(const ::I
     return new Callback_Connection_flushBatchRequests<T, CT>(instance, excb, sentcb);
 }
 
+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)
+    {
+    }
+
+    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);
+        }
+    }
+};
+
+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);
+}
+
+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);
 }
 
+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)
+    {
+    }
+
+    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);
+        }
+    }
+};
+
+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);
+}
+
+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