zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/include/Ice/MetricsFunctional.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,6 +21,23 @@ template<typename R> struct ReferenceWrapper
     }
 };
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+template<typename R> struct ReferenceWrapper<::std::shared_ptr<R> >
+{
+    static R* get(const ::std::shared_ptr<R>& v)
+    {
+        return v.get();
+    }
+};
+
+template<typename R> struct ReferenceWrapper<const ::std::shared_ptr<R>& >
+{
+    static R* get(const ::std::shared_ptr<R>& v)
+    {
+        return v.get();
+    }
+};
+#else // C++98 mapping
 template<typename R> struct ReferenceWrapper<IceInternal::ProxyHandle<R> >
 {
     static R* get(const IceInternal::ProxyHandle<R>& v)
@@ -36,7 +53,7 @@ template<typename R> struct ReferenceWrapper<const IceInternal::ProxyHandle<R>&
         return v.get();
     }
 };
-    
+
 template<typename R> struct ReferenceWrapper<IceInternal::Handle<R> >
 {
     static R* get(const IceInternal::Handle<R>& v)
@@ -52,7 +69,8 @@ template<typename R> struct ReferenceWrapper<const IceInternal::Handle<R>& >
         return v.get();
     }
 };
-    
+#endif
+
 template<typename R> struct ReferenceWrapper<R*>
 {
     static R* get(R* v)
@@ -76,7 +94,7 @@ namespace IceMX
 
 template<class T, typename Y, typename Func> struct ApplyOnMember
 {
-    ApplyOnMember(Y T::*member, Func func) : func(func), member(member)
+    ApplyOnMember(Y T::*m, Func f) : func(f), member(m)
     {
     }
 
@@ -108,7 +126,7 @@ template<typename T> struct Increment
 
 template<typename T> struct Add
 {
-    Add(T value) : value(value) { }
+    Add(T v) : value(v) { }
 
     template<typename Y>
     void operator()(Y& v)

data/ext/ice/cpp/include/Ice/MetricsObserverI.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.
@@ -36,7 +36,7 @@ public:
 
     virtual std::string operator()(const std::string&) const = 0;
 
-    virtual void initMetrics(const IceInternal::Handle<T>&) const
+    virtual void initMetrics(const ICE_INTERNAL_HANDLE<T>&) const
     {
         // To be overriden in specialization to initialize state attributes
     }
@@ -170,7 +170,6 @@ protected:
             Y (Helper::*_memberFn)() const;
         };
 
-
         template<typename I, typename O, typename Y> class MemberResolver : public Resolver
         {
         public:
@@ -183,7 +182,7 @@ protected:
             virtual std::string operator()(const Helper* r) const
             {
                 O o = (r->*_getFn)();
-                I* v = dynamic_cast<I*>(IceInternal::ReferenceWrapper<O>::get(o));
+                I* v = dynamicCast<I>(IceInternal::ReferenceWrapper<O>::get(o));
                 if(v)
                 {
                     return toString(v->*_member);
@@ -212,7 +211,7 @@ protected:
             virtual std::string operator()(const Helper* r) const
             {
                 O o = (r->*_getFn)();
-                I* v = dynamic_cast<I*>(IceInternal::ReferenceWrapper<O>::get(o));
+                I* v = dynamicCast<I>(IceInternal::ReferenceWrapper<O>::get(o));
                 if(v)
                 {
                     return toString((v->*_memberFn)());
@@ -229,6 +228,40 @@ protected:
             Y (I::*_memberFn)() const;
         };
 
+        template<typename I, typename V> static I*
+        dynamicCast(V* v)
+        {
+            return dynamic_cast<I*>(v);
+        }
+
+        template<typename I> static I*
+        dynamicCast(Ice::EndpointInfo* v)
+        {
+            for(Ice::EndpointInfo* info = v; info; info = info->underlying.get())
+            {
+                I* i = dynamic_cast<I*>(info);
+                if(i)
+                {
+                    return i;
+                }
+            }
+            return 0;
+        }
+
+        template<typename I> static I*
+        dynamicCast(Ice::ConnectionInfo* v)
+        {
+            for(Ice::ConnectionInfo* info = v; info; info = info->underlying.get())
+            {
+                I* i = dynamic_cast<I*>(info);
+                if(i)
+                {
+                    return i;
+                }
+            }
+            return 0;
+        }
+
         template<typename I> static std::string
         toString(const I& v)
         {
@@ -237,6 +270,12 @@ protected:
             return os.str();
         }
 
+        static const std::string
+        toString(const Ice::ObjectPrxPtr& p)
+        {
+            return p->ice_toString();
+        }
+
         static const std::string&
         toString(const std::string& s)
         {
@@ -266,20 +305,28 @@ protected:
     };
 };
 
-class Updater : public IceUtil::Shared
+class Updater
+#ifndef ICE_CPP11_MAPPING
+    : public virtual IceUtil::Shared
+#endif
 {
 public:
 
     virtual void update() = 0;
 };
-typedef IceUtil::Handle<Updater> UpdaterPtr;
+ICE_DEFINE_PTR(UpdaterPtr, Updater);
 
 template<typename T> class UpdaterT : public Updater
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    UpdaterT(const std::shared_ptr<T>& updater, void (T::*fn)()) :
+#else
     UpdaterT(T* updater, void (T::*fn)()) :
-        _updater(updater), _fn(fn)
+#endif
+        _updater(updater),
+        _fn(fn)
     {
     }
 
@@ -290,24 +337,39 @@ public:
 
 private:
 
-    const IceUtil::Handle<T> _updater;
+    const ICE_HANDLE<T> _updater;
     void (T::*_fn)();
 };
 
-template<typename T> Updater*
+#ifdef ICE_CPP11_MAPPING
+template<typename T> UpdaterPtr
+newUpdater(const std::shared_ptr<T>& updater, void (T::*fn)())
+{
+    if(updater)
+    {
+        return std::make_shared<UpdaterT<T>>(updater, fn);
+    }
+    else
+    {
+        return nullptr;
+    }
+}
+#else
+template<typename T> UpdaterPtr
 newUpdater(const IceInternal::Handle<T>& updater, void (T::*fn)())
 {
     if(updater)
     {
-        return new UpdaterT<T>(updater.get(), fn);
+        return UpdaterPtr(new UpdaterT<T>(updater.get(), fn));
     }
     else
     {
         return 0;
     }
 }
+#endif
 
-template<typename T> class ObserverT : virtual public ::Ice::Instrumentation::Observer
+template<typename T> class ObserverT : public virtual ::Ice::Instrumentation::Observer
 {
 public:
 
@@ -367,7 +429,6 @@ public:
         }
 
         _previousDelay = previous->_previousDelay + previous->_watch.delay();
-
         //
         // Detach entries from previous observer which are no longer
         // attached to this new observer.
@@ -391,10 +452,10 @@ public:
                 return *p;
             }
         }
-        return 0;
+        return ICE_NULLPTR;
     }
 
-    template<typename ObserverImpl, typename ObserverMetricsType> IceInternal::Handle<ObserverImpl>
+    template<typename ObserverImpl, typename ObserverMetricsType> ICE_INTERNAL_HANDLE<ObserverImpl>
     getObserver(const std::string& mapName, const MetricsHelperT<ObserverMetricsType>& helper)
     {
         std::vector<typename IceInternal::MetricsMapT<ObserverMetricsType>::EntryTPtr> metricsObjects;
@@ -409,10 +470,10 @@ public:
 
         if(metricsObjects.empty())
         {
-            return 0;
+            return ICE_NULLPTR;
         }
 
-        IceInternal::Handle<ObserverImpl> obsv = new ObserverImpl();
+        ICE_INTERNAL_HANDLE<ObserverImpl> obsv = ICE_MAKE_SHARED(ObserverImpl);
         obsv->init(helper, metricsObjects);
         return obsv;
     }
@@ -429,10 +490,15 @@ class ObserverFactoryT : public Updater, private IceUtil::Mutex
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    using ObserverImplPtrType = ::std::shared_ptr<ObserverImplType>;
+    using MetricsType = typename ObserverImplType::MetricsType;
+    using MetricsMapSeqType = std::vector<::std::shared_ptr<IceInternal::MetricsMapT<MetricsType>>>;
+#else
     typedef IceUtil::Handle<ObserverImplType> ObserverImplPtrType;
     typedef typename ObserverImplType::MetricsType MetricsType;
-
     typedef std::vector<IceUtil::Handle<IceInternal::MetricsMapT<MetricsType> > > MetricsMapSeqType;
+#endif
 
     ObserverFactoryT(const IceInternal::MetricsAdminIPtr& metrics, const std::string& name) :
         _metrics(metrics), _name(name), _enabled(0)
@@ -454,7 +520,7 @@ public:
         IceUtil::Mutex::Lock sync(*this);
         if(!_metrics)
         {
-            return 0;
+            return ICE_NULLPTR;
         }
 
         typename ObserverImplType::EntrySeqType metricsObjects;
@@ -469,10 +535,10 @@ public:
 
         if(metricsObjects.empty())
         {
-            return 0;
+            return ICE_NULLPTR;
         }
 
-        ObserverImplPtrType obsv = new ObserverImplType();
+        ObserverImplPtrType obsv = ICE_MAKE_SHARED(ObserverImplType);
         obsv->init(helper, metricsObjects);
         return obsv;
     }
@@ -480,16 +546,20 @@ public:
     template<typename ObserverPtrType> ObserverImplPtrType
     getObserver(const MetricsHelperT<MetricsType>& helper, const ObserverPtrType& observer)
     {
+#ifdef ICE_CPP11_MAPPING
+        ObserverImplPtrType old = std::dynamic_pointer_cast<ObserverImplType>(observer);
+#else
         ObserverImplPtrType old = ObserverImplPtrType::dynamicCast(observer);
+#endif
+
         if(!observer || !old)
         {
             return getObserver(helper);
         }
-
         IceUtil::Mutex::Lock sync(*this);
         if(!_metrics)
         {
-            return 0;
+            return ICE_NULLPTR;
         }
 
         typename ObserverImplType::EntrySeqType metricsObjects;
@@ -501,14 +571,13 @@ public:
                 metricsObjects.push_back(entry);
             }
         }
-
         if(metricsObjects.empty())
         {
             old->detach();
-            return 0;
+            return ICE_NULLPTR;
         }
 
-        ObserverImplPtrType obsv = new ObserverImplType();
+        ObserverImplPtrType obsv = ICE_MAKE_SHARED(ObserverImplType);
         obsv->init(helper, metricsObjects, old.get());
         return obsv;
     }
@@ -539,7 +608,11 @@ public:
             _maps.clear();
             for(std::vector<IceInternal::MetricsMapIPtr>::const_iterator p = maps.begin(); p != maps.end(); ++p)
             {
+#ifdef ICE_CPP11_MAPPING
+                _maps.push_back(::std::dynamic_pointer_cast<IceInternal::MetricsMapT<MetricsType>>(*p));
+#else
                 _maps.push_back(IceUtil::Handle<IceInternal::MetricsMapT<MetricsType> >::dynamicCast(*p));
+#endif
                 assert(_maps.back());
             }
             _enabled.exchange(_maps.empty() ? 0 : 1);

data/ext/ice/cpp/include/Ice/NativePropertiesAdmin.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.
@@ -33,22 +33,35 @@ namespace Ice
 // Ice ignores any exceptions raised by the callback.
 //
 
-class ICE_API PropertiesAdminUpdateCallback : virtual public Ice::LocalObject
+#ifndef ICE_CPP11_MAPPING
+class ICE_API PropertiesAdminUpdateCallback : public virtual Ice::LocalObject
 {
 public:
 
+    virtual ~PropertiesAdminUpdateCallback();
+
     virtual void updated(const PropertyDict&) = 0;
 };
 typedef IceUtil::Handle<PropertiesAdminUpdateCallback> PropertiesAdminUpdateCallbackPtr;
+#endif
 
-class ICE_API NativePropertiesAdmin : virtual public IceUtil::Shared
+class ICE_API NativePropertiesAdmin
+#ifndef ICE_CPP11_MAPPING
+    : public virtual IceUtil::Shared
+#endif
 {
 public:
 
+    virtual ~NativePropertiesAdmin();
+
+#ifdef ICE_CPP11_MAPPING
+    virtual std::function<void()> addUpdateCallback(std::function<void(const PropertyDict&)>) = 0;
+#else
     virtual void addUpdateCallback(const PropertiesAdminUpdateCallbackPtr&) = 0;
     virtual void removeUpdateCallback(const PropertiesAdminUpdateCallbackPtr&) = 0;
+#endif
 };
-typedef IceUtil::Handle<NativePropertiesAdmin> NativePropertiesAdminPtr;
+ICE_DEFINE_PTR(NativePropertiesAdminPtr, NativePropertiesAdmin);
 
 }
 

data/ext/ice/cpp/include/Ice/Object.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.
@@ -15,15 +15,22 @@
 #include <Ice/ObjectF.h>
 #include <Ice/ProxyF.h>
 #include <Ice/IncomingAsyncF.h>
+#include <Ice/SlicedDataF.h>
 #include <Ice/Current.h>
-#include <Ice/StreamF.h>
 #include <Ice/Format.h>
 
+namespace Ice
+{
+
+class OutputStream;
+class InputStream;
+
+}
+
 namespace IceInternal
 {
 
 class Incoming;
-class BasicStream;
 class Direct;
 class GCVisitor;
 
@@ -32,134 +39,176 @@ class GCVisitor;
 namespace Ice
 {
 
-enum DispatchStatus
-{
-    DispatchOK,
-    DispatchUserException,
-    DispatchAsync
-};
-
+ICE_API extern const Current emptyCurrent;
 
+#ifndef ICE_CPP11_MAPPING
 class ICE_API DispatchInterceptorAsyncCallback : public virtual IceUtil::Shared
 {
 public:
-    
-    virtual bool response(bool) = 0;
+
+    virtual ~DispatchInterceptorAsyncCallback();
+
+    virtual bool response() = 0;
     virtual bool exception(const std::exception&) = 0;
     virtual bool exception() = 0;
 };
-typedef IceUtil::Handle<DispatchInterceptorAsyncCallback> DispatchInterceptorAsyncCallbackPtr;
+ICE_DEFINE_PTR(DispatchInterceptorAsyncCallbackPtr, DispatchInterceptorAsyncCallback);
+#endif
 
-class ICE_API Request 
+class ICE_API Request
 {
 public:
 
-    virtual ~Request() {}
+    virtual ~Request();
     virtual const Current& getCurrent() = 0;
 };
 
-class ICE_API Object : virtual public IceUtil::Shared
+#ifdef ICE_CPP11_MAPPING
+class ICE_API Object
+{
+public:
+
+    virtual ~Object() = default;
+
+    virtual bool ice_isA(std::string, const Current&) const;
+    bool _iceD_ice_isA(IceInternal::Incoming&, const Current&);
+
+    virtual void ice_ping(const Current&) const;
+    bool _iceD_ice_ping(IceInternal::Incoming&, const Current&);
+
+    virtual std::vector< std::string> ice_ids(const Current&) const;
+    bool _iceD_ice_ids(IceInternal::Incoming&, const Current&);
+
+    virtual std::string ice_id(const Current&) const;
+    bool _iceD_ice_id(IceInternal::Incoming&, const Current&);
+
+    static const std::string& ice_staticId();
+
+    virtual bool ice_dispatch(Ice::Request&,
+                              std::function<bool()> = nullptr,
+                              std::function<bool(std::exception_ptr)> = nullptr);
+
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
+
+    struct Ice_invokeResult
+    {
+        bool returnValue;
+        std::vector<::Ice::Byte> outParams;
+    };
+
+protected:
+
+    static void _iceCheckMode(OperationMode, OperationMode);
+};
+#else
+class ICE_API Object  : public virtual IceUtil::Shared
 {
 public:
 
     virtual bool operator==(const Object&) const;
     virtual bool operator<(const Object&) const;
 
-    virtual bool ice_isA(const std::string&, const Current& = Current()) const;
-    DispatchStatus ___ice_isA(IceInternal::Incoming&, const Current&);
+    virtual bool ice_isA(const std::string&, const Current& = Ice::emptyCurrent) const;
+    bool _iceD_ice_isA(IceInternal::Incoming&, const Current&);
 
-    virtual void ice_ping(const Current&  = Current()) const;
-    DispatchStatus ___ice_ping(IceInternal::Incoming&, const Current&);
+    virtual void ice_ping(const Current&  = Ice::emptyCurrent) const;
+    bool _iceD_ice_ping(IceInternal::Incoming&, const Current&);
 
-    virtual std::vector< std::string> ice_ids(const Current& = Current()) const;
-    DispatchStatus ___ice_ids(IceInternal::Incoming&, const Current&);
+    virtual std::vector< std::string> ice_ids(const Current& = Ice::emptyCurrent) const;
+    bool _iceD_ice_ids(IceInternal::Incoming&, const Current&);
 
-    virtual const std::string& ice_id(const Current& = Current()) const;
-    DispatchStatus ___ice_id(IceInternal::Incoming&, const Current&);
+    virtual const std::string& ice_id(const Current& = Ice::emptyCurrent) const;
+    bool _iceD_ice_id(IceInternal::Incoming&, const Current&);
 
     virtual Int ice_operationAttributes(const std::string&) const;
 
-    static const std::string& ice_staticId();
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
 
-    virtual ObjectPtr ice_clone() const;
+    virtual bool _iceGcVisit(IceInternal::GCVisitor&) { return false; }
+    virtual void ice_collectable(bool) { }
 
     virtual void ice_preMarshal();
     virtual void ice_postUnmarshal();
 
-    static std::string __all[];
-
-    virtual DispatchStatus ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+    static const std::string& ice_staticId();
 
-    virtual void __write(IceInternal::BasicStream*) const;
-    virtual void __read(IceInternal::BasicStream*);
+    virtual ObjectPtr ice_clone() const;
 
-    virtual void __write(const OutputStreamPtr&) const;
-    virtual void __read(const InputStreamPtr&);
+    virtual SlicedDataPtr ice_getSlicedData() const;
 
-    virtual bool __gcVisit(IceInternal::GCVisitor&) { return false; };
-    virtual void ice_collectable(bool) { };
+    virtual bool ice_dispatch(Ice::Request&, const DispatchInterceptorAsyncCallbackPtr& = 0);
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 
 protected:
 
     Object() {} // This class is abstract.
     virtual ~Object() {}
 
-    virtual void __writeImpl(IceInternal::BasicStream*) const {}
-    virtual void __readImpl(IceInternal::BasicStream*) {}
+protected:
 
-    virtual void __writeImpl(const OutputStreamPtr&) const;
-    virtual void __readImpl(const InputStreamPtr&);
+    virtual void _iceWriteImpl(Ice::OutputStream*) const {}
+    virtual void _iceReadImpl(Ice::InputStream*) {}
 
-    static void __checkMode(OperationMode, OperationMode);
+    static void _iceCheckMode(OperationMode, OperationMode);
 };
+#endif
 
-class ICE_API Blobject : virtual public Object
+class ICE_API Blobject : public virtual Object
 {
 public:
 
     //
     // Returns true if ok, false if user exception.
     //
-    virtual bool ice_invoke(const std::vector<Byte>&, std::vector<Byte>&, const Current&) = 0;
+    virtual bool ice_invoke(ICE_IN(std::vector<Byte>), std::vector<Byte>&, const Current&) = 0;
 
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectArray : virtual public Object
+class ICE_API BlobjectArray : public virtual Object
 {
 public:
 
     //
     // Returns true if ok, false if user exception.
     //
-    virtual bool ice_invoke(const std::pair<const Byte*, const Byte*>&, std::vector<Byte>&, const Current&) = 0;
+    virtual bool ice_invoke(ICE_IN(std::pair<const Byte*, const Byte*>), std::vector<Byte>&, const Current&) = 0;
 
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectAsync : virtual public Object
+class ICE_API BlobjectAsync : public virtual Object
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void ice_invokeAsync(std::vector<Byte>,
+                                 std::function<void(bool, const std::vector<Byte>&)>,
+                                 std::function<void(std::exception_ptr)>,
+                                 const Current&) = 0;
+#else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::vector<Byte>&, const Current&) = 0;
-
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+#endif
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-class ICE_API BlobjectArrayAsync : virtual public Object
+class ICE_API BlobjectArrayAsync : public virtual Object
 {
 public:
 
+#ifdef ICE_CPP11_MAPPING
+    virtual void ice_invokeAsync(std::pair<const Byte*, const Byte*>,
+                                 std::function<void(bool, const std::pair<const Byte*, const Byte*>&)>,
+                                 std::function<void(std::exception_ptr)>,
+                                 const Current&) = 0;
+#else
     virtual void ice_invoke_async(const AMD_Object_ice_invokePtr&, const std::pair<const Byte*, const Byte*>&,
                                   const Current&) = 0;
-
-    virtual DispatchStatus __dispatch(IceInternal::Incoming&, const Current&);
+#endif
+    virtual bool _iceDispatch(IceInternal::Incoming&, const Current&);
 };
 
-ICE_API void ice_writeObject(const OutputStreamPtr&, const ObjectPtr&);
-ICE_API void ice_readObject(const InputStreamPtr&, ObjectPtr&);
-
 }
 
 #endif