zeroc-ice 3.6.5 → 3.7.4

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

@@ -1,28 +1,32 @@
-// **********************************************************************
 //
-// 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_FACTORYTABLE_H
 #define ICE_FACTORYTABLE_H
 
 #include <IceUtil/Mutex.h>
 #include <Ice/UserExceptionFactory.h>
-#include <Ice/ObjectFactoryF.h>
-
+#include <Ice/ValueFactory.h>
 
 namespace Ice
 {
 
+/**
+ * The base class for a compact ID resolver. Subclasses must implement resolve.
+ * The resolver can be installed via InitializationData.
+ * \headerfile Ice/Ice.h
+ */
 class ICE_API CompactIdResolver : public IceUtil::Shared
 {
 public:
 
-    virtual ::std::string resolve(Ice::Int) const = 0;
+    /**
+     * Called by the Ice run time when a compact ID must be translated into a type ID.
+     * @param id The compact ID.
+     * @return The fully-scoped Slice type ID, or an empty string if the compact ID is unknown.
+     */
+    virtual ::std::string resolve(Ice::Int id) const = 0;
 };
 typedef IceUtil::Handle<CompactIdResolver> CompactIdResolverPtr;
 
@@ -35,13 +39,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 +55,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,17 +1,12 @@
-// **********************************************************************
 //
-// 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_FACTORYTABLEINIT_H
 #define ICE_FACTORYTABLEINIT_H
 
 #include <Ice/FactoryTable.h>
-#include <Ice/DefaultObjectFactory.h>
+#include <Ice/DefaultValueFactory.h>
 
 namespace IceInternal
 {
@@ -26,18 +21,17 @@ public:
 
 static FactoryTableInit factoryTableInitializer;    // Dummy variable to force initialization of factoryTable
 
-extern ICE_API FactoryTable* factoryTable;
-
+extern ICE_API FactoryTable* factoryTable ICE_GLOBAL_VAR_SUFFIX;
 
 class ICE_API CompactIdInit
 {
 public:
-    
+
     CompactIdInit(const char*, int);
-        
     ~CompactIdInit();
-    
+
 private:
+
     const int _compactId;
 };
 
@@ -45,41 +39,44 @@ template
 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,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_FORMAT_H
 #define ICE_FORMAT_H
@@ -15,22 +10,26 @@
 namespace Ice
 {
 
-//
-// This enumeration describes the possible formats for classes and exceptions.
-//
+/**
+ * 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.
-    //
+    /**
+     * Indicates that no preference was specified.
+     */
     DefaultFormat,
-    //
-    // A minimal format that eliminates the possibility for slicing unrecognized types.
-    //
+    /**
+     * A minimal format that eliminates the possibility for slicing unrecognized types.
+     */
     CompactFormat,
-    //
-    // Allow slicing and preserve slices for unknown types.
-    //
+    /**
+     * Allow slicing and preserve slices for unknown types.
+     */
     SlicedFormat
 };
 

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

@@ -1,15 +1,12 @@
-// **********************************************************************
 //
-// 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_FUNCTIONAL_H
 #define ICE_FUNCTIONAL_H
 
+#ifndef ICE_CPP11_MAPPING
+
 #include <IceUtil/Functional.h>
 #include <Ice/Handle.h>
 
@@ -21,118 +18,121 @@
 namespace Ice
 {
 
+/// \cond INTERNAL
 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);
 }
+/// \endcond
 
 }
 
+#   endif
 #endif

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

@@ -1,15 +1,12 @@
-// **********************************************************************
 //
-// 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_GC_OBJECT_H
 #define ICE_GC_OBJECT_H
 
+#ifndef ICE_CPP11_MAPPING
+
 #include <Ice/Object.h>
 
 #include <IceUtil/MutexPtrLock.h>
@@ -31,7 +28,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 +50,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 +72,5 @@ private:
 }
 
 #endif
+
+#endif