zeroc-ice 3.6.5 → 3.7.0

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

@@ -0,0 +1,52 @@
+// **********************************************************************
+//
+// 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_STRING_CONVERTER_H
+#define ICE_STRING_CONVERTER_H
+
+#include <Ice/Config.h>
+#include <IceUtil/StringConverter.h>
+#include <IceUtil/ConsoleUtil.h>
+
+namespace Ice
+{
+
+typedef IceUtil::UTF8Buffer UTF8Buffer;
+typedef IceUtil::StringConverter StringConverter;
+typedef IceUtil::StringConverterPtr StringConverterPtr;
+typedef IceUtil::WstringConverter WstringConverter;
+typedef IceUtil::WstringConverterPtr WstringConverterPtr;
+
+typedef IceUtil::IllegalConversionException IllegalConversionException;
+
+#ifdef ICE_CPP11_MAPPING
+template<typename charT>
+using BasicStringConverter = IceUtil::BasicStringConverter<charT>;
+#endif
+
+#ifdef _WIN32
+using IceUtil::createWindowsStringConverter;
+#endif
+
+using IceUtil::createUnicodeWstringConverter;
+
+using IceUtil::setProcessStringConverter;
+using IceUtil::getProcessStringConverter;
+using IceUtil::setProcessWstringConverter;
+using IceUtil::getProcessWstringConverter;
+
+using IceUtil::wstringToString;
+using IceUtil::stringToWstring;
+
+using IceUtil::nativeToUTF8;
+using IceUtil::UTF8ToNative;
+
+}
+
+#endif

data/ext/ice/cpp/include/Ice/ThreadPoolF.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/{slice/Ice/ObjectFactoryF.ice → ext/ice/cpp/include/Ice/UUID.h}

@@ -1,21 +1,23 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
-#pragma once
+#ifndef ICE_UUID_H
+#define ICE_UUID_H
 
-[["cpp:header-ext:h", "objc:header-dir:objc"]]
+#include <Ice/Config.h>
+#include <IceUtil/UUID.h>
 
-["objc:prefix:ICE"]
-module Ice
+namespace Ice
 {
 
-local interface ObjectFactory;
+using IceUtil::generateUUID;
 
-};
+}
 
+#endif

data/ext/ice/cpp/include/{IceUtil → Ice}/UniquePtr.h

@@ -1,25 +1,26 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 
-#ifndef ICE_UTIL_UNIQUE_PTR_H
-#define ICE_UTIL_UNIQUE_PTR_H
+#ifndef ICE_UNIQUE_PTR_H
+#define ICE_UNIQUE_PTR_H
 
-#include <IceUtil/Config.h>
+#include <Ice/Config.h>
 
-namespace IceUtil
+namespace IceInternal
 {
 
-//
-// This is temporary and very partial placeholder for std::unique_ptr,
-// which is not yet widely available.
-//
+#ifdef ICE_CPP11_MAPPING
 
+template<typename T>
+using UniquePtr = std::unique_ptr<T>;
+
+#else
 
 template<typename T>
 class UniquePtr
@@ -31,17 +32,6 @@ public:
     {
     }
 
-    UniquePtr(UniquePtr& o) :
-        _ptr(o.release())
-    {
-    }
-
-    UniquePtr& operator=(UniquePtr& o)
-    {
-        reset(o.release());
-        return *this;
-    }
-
     ~UniquePtr()
     {
         if(_ptr != 0)
@@ -72,18 +62,22 @@ public:
     {
         return *_ptr;
     }
-    
+
     T* operator->() const
     {
         return _ptr;
     }
 
-
     T* get() const
     {
         return _ptr;
     }
 
+    operator bool() const
+    {
+        return _ptr != 0;
+    }
+
     void swap(UniquePtr& a)
     {
         T* tmp = a._ptr;
@@ -93,9 +87,14 @@ public:
 
 private:
 
+    UniquePtr(UniquePtr&);
+    UniquePtr& operator=(UniquePtr&);
+
     T* _ptr;
 };
 
+#endif
+
 } // End of namespace IceUtil
 
 #endif

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

@@ -0,0 +1,98 @@
+// **********************************************************************
+//
+// 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_UNIQUE_REF_H
+#define ICE_UNIQUE_REF_H
+
+#ifdef __APPLE__
+
+#include <CoreFoundation/CoreFoundation.h>
+
+namespace IceInternal
+{
+
+//
+// UniqueRef helper class for CoreFoundation classes, comparable to std::unique_ptr
+//
+template<typename R>
+class UniqueRef
+{
+public:
+
+    explicit UniqueRef(R ref = 0) :
+        _ref(ref)
+    {
+    }
+
+    ~UniqueRef()
+    {
+        if(_ref != 0)
+        {
+            CFRelease(_ref);
+        }
+    }
+
+    R release()
+    {
+        R r = _ref;
+        _ref = 0;
+        return r;
+    }
+
+    void reset(R ref = 0)
+    {
+        assert(ref == 0 || ref != _ref);
+
+        if(_ref != 0)
+        {
+            CFRelease(_ref);
+        }
+        _ref = ref;
+    }
+
+    void retain(R ref)
+    {
+        reset(ref ? (R)CFRetain(ref) : ref);
+    }
+
+    R& get()
+    {
+        return _ref;
+    }
+
+    R get() const
+    {
+        return _ref;
+    }
+
+    operator bool() const
+    {
+        return _ref != 0;
+    }
+
+    void swap(UniqueRef& a)
+    {
+        R tmp = a._ref;
+        a._ref = _ref;
+        _ref = tmp;
+    }
+
+private:
+
+    UniqueRef(UniqueRef&);
+    UniqueRef& operator=(UniqueRef&);
+
+    R _ref;
+};
+
+}
+
+#endif
+
+#endif

data/ext/ice/cpp/include/Ice/UserExceptionFactory.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.
@@ -14,33 +14,64 @@
 #include <IceUtil/Handle.h>
 #include <Ice/Config.h>
 
+#ifdef ICE_CPP11_MAPPING
+
+namespace Ice
+{
+
+using UserExceptionFactory = std::function<void(const std::string&)>;
+
+}
+
 namespace IceInternal
 {
 
+template<class E>
+void
+#ifdef NDEBUG
+defaultUserExceptionFactory(const std::string&)
+#else
+defaultUserExceptionFactory(const std::string& typeId)
+#endif
+{
+    assert(typeId == E::ice_staticId());
+    throw E();
+}
+
+}
+#else
+
+namespace Ice
+{
+
 class ICE_API UserExceptionFactory : public IceUtil::Shared
 {
 public:
 
     virtual void createAndThrow(const ::std::string&) = 0;
-    virtual ~UserExceptionFactory() {}
+    virtual ~UserExceptionFactory();
 };
-
 typedef ::IceUtil::Handle<UserExceptionFactory> UserExceptionFactoryPtr;
 
+}
+
+namespace IceInternal
+{
+
 template<class E>
-class DefaultUserExceptionFactory : public UserExceptionFactory
+class DefaultUserExceptionFactory : public Ice::UserExceptionFactory
 {
 public:
-    
+
     DefaultUserExceptionFactory(const ::std::string& typeId) :
         _typeId(typeId)
     {
     }
 
-#ifndef NDEBUG
-    virtual void createAndThrow(const ::std::string& typeId)
-#else
+#ifdef NDEBUG
     virtual void createAndThrow(const ::std::string&)
+#else
+    virtual void createAndThrow(const ::std::string& typeId)
 #endif
     {
         assert(typeId == _typeId);
@@ -54,3 +85,4 @@ private:
 }
 
 #endif
+#endif

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

@@ -0,0 +1,104 @@
+// **********************************************************************
+//
+// 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_VALUE_H
+#define ICE_VALUE_H
+
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
+#include <Ice/ValueF.h>
+#include <Ice/SlicedDataF.h>
+
+#include <Ice/OutputStream.h>
+#include <Ice/InputStream.h>
+
+namespace Ice
+{
+
+class ICE_API Value
+{
+public:
+
+    // See "Rule of zero" at http://en.cppreference.com/w/cpp/language/rule_of_three
+    // The virtual dtor is actually not stricly necessary since Values are always stored
+    // in std::shared_ptr
+
+    Value() = default;
+    Value(const Value&) = default;
+    Value(Value&&) = default;
+    Value& operator=(const Value&) = default;
+    Value& operator=(Value&&) = default;
+    virtual ~Value() = default;
+
+    virtual void ice_preMarshal();
+    virtual void ice_postUnmarshal();
+
+    virtual std::string ice_id() const;
+    static const std::string& ice_staticId();
+
+    std::shared_ptr<Value> ice_clone() const;
+
+    virtual std::shared_ptr<SlicedData> ice_getSlicedData() const;
+
+    virtual void _iceWrite(Ice::OutputStream*) const;
+    virtual void _iceRead(Ice::InputStream*);
+
+protected:
+
+    virtual std::shared_ptr<Value> _iceCloneImpl() const = 0;
+    virtual void _iceWriteImpl(Ice::OutputStream*) const {}
+    virtual void _iceReadImpl(Ice::InputStream*) {}
+};
+
+template<typename T, typename Base> class ValueHelper : public Base
+{
+public:
+
+    using Base::Base;
+
+    ValueHelper() = default;
+
+    std::shared_ptr<T> ice_clone() const
+    {
+        return std::static_pointer_cast<T>(_iceCloneImpl());
+    }
+
+    virtual std::string ice_id() const override
+    {
+        return T::ice_staticId();
+    }
+
+protected:
+
+    virtual std::shared_ptr<Value> _iceCloneImpl() const override
+    {
+        return std::make_shared<T>(static_cast<const T&>(*this));
+    }
+
+    virtual void _iceWriteImpl(Ice::OutputStream* os) const override
+    {
+        os->startSlice(T::ice_staticId(), -1, std::is_same<Base, Ice::Value>::value ? true : false);
+        Ice::StreamWriter<T, Ice::OutputStream>::write(os, static_cast<const T&>(*this));
+        os->endSlice();
+        Base::_iceWriteImpl(os);
+    }
+
+    virtual void _iceReadImpl(Ice::InputStream* is) override
+    {
+        is->startSlice();
+        Ice::StreamReader<T, Ice::InputStream>::read(is, static_cast<T&>(*this));
+        is->endSlice();
+        Base::_iceReadImpl(is);
+    }
+};
+
+}
+#endif // C++11 mapping end
+
+#endif