zeroc-ice 3.6.5 → 3.7.0

data/ext/ice/cpp/include/Ice/FactoryTable.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.
@@ -12,8 +12,7 @@
 
 #include <IceUtil/Mutex.h>
 #include <Ice/UserExceptionFactory.h>
-#include <Ice/ObjectFactoryF.h>
-
+#include <Ice/ValueFactory.h>
 
 namespace Ice
 {
@@ -35,13 +34,13 @@ class ICE_API FactoryTable : private IceUtil::noncopyable
 {
 public:
 
-    void addExceptionFactory(const ::std::string&, const IceInternal::UserExceptionFactoryPtr&);
-    IceInternal::UserExceptionFactoryPtr getExceptionFactory(const ::std::string&) const;
+    void addExceptionFactory(const ::std::string&, ICE_IN(ICE_DELEGATE(::Ice::UserExceptionFactory)));
+    ICE_DELEGATE(::Ice::UserExceptionFactory) getExceptionFactory(const ::std::string&) const;
     void removeExceptionFactory(const ::std::string&);
 
-    void addObjectFactory(const ::std::string&, const Ice::ObjectFactoryPtr&);
-    Ice::ObjectFactoryPtr getObjectFactory(const ::std::string&) const;
-    void removeObjectFactory(const ::std::string&);
+    void addValueFactory(const ::std::string&, ICE_IN(ICE_DELEGATE(::Ice::ValueFactory)));
+    ICE_DELEGATE(::Ice::ValueFactory) getValueFactory(const ::std::string&) const;
+    void removeValueFactory(const ::std::string&);
 
     void addTypeId(int, const ::std::string&);
     std::string getTypeId(int) const;
@@ -51,13 +50,13 @@ private:
 
     IceUtil::Mutex _m;
 
-    typedef ::std::pair<IceInternal::UserExceptionFactoryPtr, int> EFPair;
+    typedef ::std::pair< ICE_DELEGATE(::Ice::UserExceptionFactory), int> EFPair;
     typedef ::std::map< ::std::string, EFPair> EFTable;
     EFTable _eft;
 
-    typedef ::std::pair<Ice::ObjectFactoryPtr, int> OFPair;
-    typedef ::std::map< ::std::string, OFPair> OFTable;
-    OFTable _oft;
+    typedef ::std::pair< ICE_DELEGATE(::Ice::ValueFactory), int> VFPair;
+    typedef ::std::map< ::std::string, VFPair> VFTable;
+    VFTable _vft;
 
     typedef ::std::pair< ::std::string, int> TypeIdPair;
     typedef ::std::map<int, TypeIdPair> TypeIdTable;

data/ext/ice/cpp/include/Ice/FactoryTableInit.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.
@@ -11,7 +11,7 @@
 #define ICE_FACTORYTABLEINIT_H
 
 #include <Ice/FactoryTable.h>
-#include <Ice/DefaultObjectFactory.h>
+#include <Ice/DefaultValueFactory.h>
 
 namespace IceInternal
 {
@@ -28,16 +28,15 @@ static FactoryTableInit factoryTableInitializer;    // Dummy variable to force i
 
 extern ICE_API FactoryTable* factoryTable;
 
-
 class ICE_API CompactIdInit
 {
 public:
-    
+
     CompactIdInit(const char*, int);
-        
     ~CompactIdInit();
-    
+
 private:
+
     const int _compactId;
 };
 
@@ -45,41 +44,44 @@ template<class E>
 class DefaultUserExceptionFactoryInit
 {
 public:
-    
-    DefaultUserExceptionFactoryInit(const char* typeId) :
-        _typeId(typeId)
+
+    DefaultUserExceptionFactoryInit(const char* tId) : typeId(tId)
     {
-        factoryTable->addExceptionFactory(_typeId, new DefaultUserExceptionFactory<E>(_typeId));
+#ifdef ICE_CPP11_MAPPING
+        factoryTable->addExceptionFactory(typeId, defaultUserExceptionFactory<E>);
+#else
+        factoryTable->addExceptionFactory(typeId, new DefaultUserExceptionFactory<E>(typeId));
+#endif
     }
 
     ~DefaultUserExceptionFactoryInit()
     {
-        factoryTable->removeExceptionFactory(_typeId);
+        factoryTable->removeExceptionFactory(typeId);
     }
-    
-private:
-    const ::std::string _typeId;
+
+    const ::std::string typeId;
 };
 
 template<class O>
-class DefaultObjectFactoryInit
+class DefaultValueFactoryInit
 {
 public:
-    
-    DefaultObjectFactoryInit(const char* typeId) :
-        _typeId(typeId)
+
+    DefaultValueFactoryInit(const char* tId) : typeId(tId)
     {
-        factoryTable->addObjectFactory(_typeId, new DefaultObjectFactory<O>(_typeId));
+#ifdef ICE_CPP11_MAPPING
+        factoryTable->addValueFactory(typeId, defaultValueFactory<O>);
+#else
+        factoryTable->addValueFactory(typeId, new DefaultValueFactory<O>(typeId));
+#endif
     }
 
-    ~DefaultObjectFactoryInit()
+    ~DefaultValueFactoryInit()
     {
-        factoryTable->removeObjectFactory(_typeId);
+        factoryTable->removeValueFactory(typeId);
     }
-    
-private:
-    const ::std::string _typeId;
- 
+
+    const ::std::string typeId;
 };
 
 }

data/ext/ice/cpp/include/Ice/Format.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.
@@ -18,7 +18,12 @@ namespace Ice
 //
 // This enumeration describes the possible formats for classes and exceptions.
 //
+
+#ifdef ICE_CPP11_MAPPING
+enum class FormatType : unsigned char
+#else
 enum FormatType
+#endif
 {
     //
     // Indicates that no preference was specified.

data/ext/ice/cpp/include/Ice/Functional.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,115 +22,115 @@ namespace Ice
 {
 
 template<class R, class T>
-inline ::IceUtilInternal::MemFun<R, T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::MemFun<R, T, ICE_INTERNAL_HANDLE<T> >
 memFun(R (T::*p)(void))
 {
-    return ::IceUtilInternal::MemFun<R, T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::MemFun<R, T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class R, class T, class A>
-inline ::IceUtilInternal::MemFun1<R, T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::MemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>
 memFun1(R (T::*p)(A))
 {
-    return ::IceUtilInternal::MemFun1<R, T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::MemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class T>
-inline ::IceUtilInternal::VoidMemFun<T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::VoidMemFun<T, ICE_INTERNAL_HANDLE<T> >
 voidMemFun(void (T::*p)(void))
 {
-    return ::IceUtilInternal::VoidMemFun<T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::VoidMemFun<T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class T, class A>
-inline ::IceUtilInternal::VoidMemFun1<T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::VoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>
 voidMemFun1(void (T::*p)(A))
 {
-    return ::IceUtilInternal::VoidMemFun1<T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::VoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class R, class K, class T>
-inline ::IceUtilInternal::SecondMemFun<R, K, T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::SecondMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >
 secondMemFun(R (T::*p)(void))
 {
-    return ::IceUtilInternal::SecondMemFun<R, K, T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::SecondMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondMemFun1<R, K, T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::SecondMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>
 secondMemFun1(R (T::*p)(A))
 {
-    return ::IceUtilInternal::SecondMemFun1<R, K, T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class K, class T>
-inline ::IceUtilInternal::SecondVoidMemFun<K, T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::SecondVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >
 secondVoidMemFun(void (T::*p)(void))
 {
-    return ::IceUtilInternal::SecondVoidMemFun<K, T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::SecondVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class K, class T, class A>
-inline ::IceUtilInternal::SecondVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::SecondVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>
 secondVoidMemFun1(void (T::*p)(A))
 {
-    return ::IceUtilInternal::SecondVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class R, class T>
-inline ::IceUtilInternal::ConstMemFun<R, T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::ConstMemFun<R, T, ICE_INTERNAL_HANDLE<T> >
 constMemFun(R (T::*p)(void) const)
 {
-    return ::IceUtilInternal::ConstMemFun<R, T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::ConstMemFun<R, T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class R, class T, class A>
-inline ::IceUtilInternal::ConstMemFun1<R, T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::ConstMemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>
 constMemFun1(R (T::*p)(A) const)
 {
-    return ::IceUtilInternal::ConstMemFun1<R, T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::ConstMemFun1<R, T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class T>
-inline ::IceUtilInternal::ConstVoidMemFun<T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::ConstVoidMemFun<T, ICE_INTERNAL_HANDLE<T> >
 constVoidMemFun(void (T::*p)(void) const)
 {
-    return ::IceUtilInternal::ConstVoidMemFun<T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::ConstVoidMemFun<T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class T, class A>
-inline ::IceUtilInternal::ConstVoidMemFun1<T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::ConstVoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>
 constVoidMemFun1(void (T::*p)(A) const)
 {
-    return ::IceUtilInternal::ConstVoidMemFun1<T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::ConstVoidMemFun1<T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class R, class K, class T>
-inline ::IceUtilInternal::SecondConstMemFun<R, K, T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::SecondConstMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >
 secondConstMemFun(R (T::*p)(void) const)
 {
-    return ::IceUtilInternal::SecondConstMemFun<R, K, T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::SecondConstMemFun<R, K, T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class R, class K, class T, class A>
-inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::SecondConstMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>
 secondConstMemFun1(R (T::*p)(A) const)
 {
-    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondConstMemFun1<R, K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 template<class K, class T>
-inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, ::IceInternal::Handle<T> >
+inline ::IceUtilInternal::SecondConstVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >
 secondConstVoidMemFun(void (T::*p)(void) const)
 {
-    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, ::IceInternal::Handle<T> >(p);
+    return ::IceUtilInternal::SecondConstVoidMemFun<K, T, ICE_INTERNAL_HANDLE<T> >(p);
 }
 
 template<class K, class T, class A>
-inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>
+inline ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>
 secondConstVoidMemFun1(void (T::*p)(A) const)
 {
-    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ::IceInternal::Handle<T>, A>(p);
+    return ::IceUtilInternal::SecondConstVoidMemFun1<K, T, ICE_INTERNAL_HANDLE<T>, A>(p);
 }
 
 }

data/ext/ice/cpp/include/Ice/GCObject.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_GC_OBJECT_H
 #define ICE_GC_OBJECT_H
 
+#ifndef ICE_CPP11_MAPPING
+
 #include <Ice/Object.h>
 
 #include <IceUtil/MutexPtrLock.h>
@@ -31,7 +33,7 @@ public:
     virtual bool visit(GCObject*) = 0;
 };
 
-class ICE_API GCObject : virtual public Ice::Object
+class ICE_API GCObject : public virtual Ice::Object
 {
 public:
 
@@ -53,16 +55,16 @@ public:
     //
     // Override Object methods
     //
-    virtual bool __gcVisit(GCVisitor&);
+    virtual bool _iceGcVisit(GCVisitor&);
     virtual void ice_collectable(bool);
 
     //
     // This method is implemented by Slice classes to visit class
     // members.
     //
-    virtual void __gcVisitMembers(IceInternal::GCVisitor&) = 0;
+    virtual void _iceGcVisitMembers(IceInternal::GCVisitor&) = 0;
 
-    int __getRefUnsafe()
+    int _iceGetRefUnsafe()
     {
         return _ref;
     }
@@ -75,3 +77,5 @@ private:
 }
 
 #endif
+
+#endif

data/ext/ice/cpp/include/Ice/Handle.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.
@@ -46,7 +46,7 @@ public:
             upCast(this->_ptr)->__incRef();
         }
     }
-    
+
     template<typename Y>
     Handle(const Handle<Y>& r)
     {
@@ -78,7 +78,7 @@ public:
             upCast(this->_ptr)->__incRef();
         }
     }
-    
+
     ~Handle()
     {
         if(this->_ptr)
@@ -86,7 +86,7 @@ public:
             upCast(this->_ptr)->__decRef();
         }
     }
-    
+
     Handle& operator=(T* p)
     {
         if(this->_ptr != p)
@@ -106,7 +106,7 @@ public:
         }
         return *this;
     }
-        
+
     template<typename Y>
     Handle& operator=(const Handle<Y>& r)
     {
@@ -168,7 +168,7 @@ public:
         }
         return *this;
     }
-        
+
     template<class Y>
     static Handle dynamicCast(const ::IceUtil::HandleBase<Y>& r)
     {
@@ -180,11 +180,6 @@ public:
     {
         return Handle(dynamic_cast<T*>(p));
     }
-
-    void __clearHandleUnsafe()
-    {
-        this->_ptr = 0;
-    }
 };
 
 }

data/ext/ice/cpp/include/Ice/Ice.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.
@@ -12,8 +12,9 @@
 
 #include <IceUtil/PushDisableWarnings.h>
 #include <Ice/Config.h>
-#include <Ice/DeprecatedStringConverter.h>
+#include <Ice/Comparable.h>
 #include <Ice/Initialize.h>
+#include <Ice/Optional.h>
 #include <Ice/LocalException.h>
 #include <Ice/PropertiesAdmin.h>
 #include <Ice/Properties.h>
@@ -31,13 +32,12 @@
 #include <Ice/OutgoingAsync.h>
 #include <Ice/IncomingAsync.h>
 #include <Ice/Process.h>
-#if !defined(ICE_OS_WINRT) && (!defined(__APPLE__) || TARGET_OS_IPHONE == 0)
+#if !defined(ICE_OS_UWP) && (!defined(__APPLE__) || TARGET_OS_IPHONE == 0)
 #   include <Ice/Application.h>
 #endif
 #include <Ice/Connection.h>
 #include <Ice/ConnectionAsync.h>
 #include <Ice/Functional.h>
-#include <Ice/Stream.h>
 #include <Ice/ImplicitContext.h>
 #include <Ice/Locator.h>
 #include <Ice/Router.h>
@@ -47,10 +47,14 @@
 #include <Ice/Instrumentation.h>
 #include <Ice/Metrics.h>
 #include <Ice/SliceChecksums.h>
-#if !defined(ICE_OS_WINRT) && (!defined(__APPLE__) || TARGET_OS_IPHONE == 0)
+#if !defined(ICE_OS_UWP) && (!defined(__APPLE__) || TARGET_OS_IPHONE == 0)
 #   include <Ice/Service.h>
 #endif
 #include <Ice/RegisterPlugins.h>
+#include <Ice/InterfaceByValue.h>
+#include <Ice/StringConverter.h>
+#include <Ice/IconvStringConverter.h>
+#include <Ice/UUID.h>
 #include <IceUtil/PopDisableWarnings.h>
 
 #endif