zeroc-ice 3.6.5 → 3.7.4

data/ext/ice/cpp/src/Ice/PropertiesAdminI.cpp

@@ -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.
-//
-// **********************************************************************
 
 #include <Ice/PropertiesAdminI.h>
+#include <Ice/Instance.h>
 #include <Ice/Logger.h>
 #include <Ice/LoggerUtil.h>
+#include <Ice/ThreadPool.h>
 
 using namespace std;
 using namespace Ice;
@@ -21,31 +18,55 @@ const char* traceCategory = "Admin.Properties";
 
 }
 
+#ifndef ICE_CPP11_MAPPING
+PropertiesAdminUpdateCallback::~PropertiesAdminUpdateCallback()
+{
+    // Out of line to avoid weak vtable
+}
+#endif
+
+NativePropertiesAdmin::~NativePropertiesAdmin()
+{
+    // Out of line to avoid weak vtable
+}
+
 namespace IceInternal
 {
 
-PropertiesAdminI::PropertiesAdminI(const PropertiesPtr& properties, const LoggerPtr& logger) :
-    _properties(properties), _logger(logger)
+PropertiesAdminI::PropertiesAdminI(const InstancePtr& instance) :
+    _properties(instance->initializationData().properties),
+    _logger(instance->initializationData().logger)
 {
 }
 
 string
+#ifdef ICE_CPP11_MAPPING
+PropertiesAdminI::getProperty(string name, const Current&)
+#else
 PropertiesAdminI::getProperty(const string& name, const Current&)
+#endif
 {
     Lock sync(*this);
     return _properties->getProperty(name);
 }
 
 PropertyDict
+#ifdef ICE_CPP11_MAPPING
+PropertiesAdminI::getPropertiesForPrefix(string prefix, const Current&)
+#else
 PropertiesAdminI::getPropertiesForPrefix(const string& prefix, const Current&)
+#endif
 {
     Lock sync(*this);
     return _properties->getPropertiesForPrefix(prefix);
 }
 
 void
-PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr& cb, const PropertyDict& props,
-                                           const Current&)
+#ifdef ICE_CPP11_MAPPING
+PropertiesAdminI::setProperties(PropertyDict props, const Current&)
+#else
+PropertiesAdminI::setProperties(const PropertyDict& props, const Current&)
+#endif
 {
     Lock sync(*this);
 
@@ -160,35 +181,71 @@ PropertiesAdminI::setProperties_async(const AMD_PropertiesAdmin_setPropertiesPtr
         _properties->setProperty(p->first, "");
     }
 
-    //
-    // Send the response now so that we do not block the client during
-    // the call to the update callback.
-    //
-    cb->ice_response();
-
-    //
-    // Copy the callbacks to allow callbacks to update the callbacks.
-    //
-    vector<PropertiesAdminUpdateCallbackPtr> callbacks = _updateCallbacks;
-    if(!callbacks.empty())
+    if(!_updateCallbacks.empty())
     {
         PropertyDict changes = added;
         changes.insert(changed.begin(), changed.end());
         changes.insert(removed.begin(), removed.end());
-        for(vector<PropertiesAdminUpdateCallbackPtr>::const_iterator p = callbacks.begin(); p != callbacks.end(); ++p)
+
+        // Copy callbacks to allow callbacks to update callbacks
+#ifdef ICE_CPP11_MAPPING
+        auto callbacks = _updateCallbacks;
+        for(const auto& cb : callbacks)
+#else
+        vector<PropertiesAdminUpdateCallbackPtr> callbacks = _updateCallbacks;
+        for(vector<PropertiesAdminUpdateCallbackPtr>::const_iterator q = callbacks.begin(); q != callbacks.end(); ++q)
+#endif
         {
             try
             {
-                (*p)->updated(changes);
+#ifdef ICE_CPP11_MAPPING
+                cb(changes);
+#else
+                (*q)->updated(changes);
+#endif
+            }
+            catch(const std::exception& ex)
+            {
+                if(_properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 1)
+                {
+                    Warning out(_logger);
+                    out << "properties admin update callback raised unexpected exception:\n" << ex;
+                }
             }
             catch(...)
             {
-                // Ignore.
+                if(_properties->getPropertyAsIntWithDefault("Ice.Warn.Dispatch", 1) > 1)
+                {
+                    Warning out(_logger);
+                    out << "properties admin update callback raised unexpected exception:\nunknown c++ exception";
+                }
             }
         }
     }
 }
 
+#ifdef ICE_CPP11_MAPPING
+
+std::function<void()>
+PropertiesAdminI::addUpdateCallback(std::function<void(const Ice::PropertyDict&)> cb)
+{
+    Lock sync(*this);
+
+    auto p = _updateCallbacks.insert(_updateCallbacks.end(), std::move(cb));
+    auto propertiesAdmin = shared_from_this();
+
+    return [p, propertiesAdmin] { propertiesAdmin->removeUpdateCallback(p); };
+}
+
+void
+PropertiesAdminI::removeUpdateCallback(std::list<std::function<void(const Ice::PropertyDict&)>>::iterator p)
+{
+    Lock sync(*this);
+    _updateCallbacks.erase(p);
+}
+
+#else
+
 void
 PropertiesAdminI::addUpdateCallback(const PropertiesAdminUpdateCallbackPtr& cb)
 {
@@ -203,4 +260,6 @@ PropertiesAdminI::removeUpdateCallback(const PropertiesAdminUpdateCallbackPtr& c
     _updateCallbacks.erase(remove(_updateCallbacks.begin(), _updateCallbacks.end(), cb), _updateCallbacks.end());
 }
 
+#endif
+
 }

data/ext/ice/cpp/src/Ice/PropertiesAdminI.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_PROPERTIES_ADMIN_I_H
 #define ICE_PROPERTIES_ADMIN_I_H
@@ -16,29 +11,53 @@
 #include <Ice/NativePropertiesAdmin.h>
 #include <Ice/LoggerF.h>
 
+#ifdef ICE_CPP11_MAPPING
+#include <list>
+#endif
+
 namespace IceInternal
 {
 
-class PropertiesAdminI : public Ice::PropertiesAdmin, public Ice::NativePropertiesAdmin, private IceUtil::RecMutex
+class PropertiesAdminI : public Ice::PropertiesAdmin, public Ice::NativePropertiesAdmin,
+#ifdef ICE_CPP11_MAPPING
+                         public std::enable_shared_from_this<PropertiesAdminI>,
+#endif
+                         private IceUtil::RecMutex
 {
 public:
 
-    PropertiesAdminI(const Ice::PropertiesPtr&, const Ice::LoggerPtr&);
+    PropertiesAdminI(const InstancePtr&);
+
+#ifdef ICE_CPP11_MAPPING
+    virtual std::string getProperty(std::string, const Ice::Current&) override;
+    virtual Ice::PropertyDict getPropertiesForPrefix(std::string, const Ice::Current&) override;
+    virtual void setProperties(::Ice::PropertyDict, const Ice::Current&) override;
 
+    virtual std::function<void()> addUpdateCallback(std::function<void(const Ice::PropertyDict&)>) override;
+    void removeUpdateCallback(std::list<std::function<void(const Ice::PropertyDict&)>>::iterator);
+
+#else
     virtual std::string getProperty(const std::string&, const Ice::Current&);
     virtual Ice::PropertyDict getPropertiesForPrefix(const std::string&, const Ice::Current&);
-    virtual void setProperties_async(const Ice::AMD_PropertiesAdmin_setPropertiesPtr&, const Ice::PropertyDict&, const Ice::Current&);
+    virtual void setProperties(const Ice::PropertyDict&, const Ice::Current&);
 
     virtual void addUpdateCallback(const Ice::PropertiesAdminUpdateCallbackPtr&);
     virtual void removeUpdateCallback(const Ice::PropertiesAdminUpdateCallbackPtr&);
+#endif
 
 private:
 
     const Ice::PropertiesPtr _properties;
     const Ice::LoggerPtr _logger;
+
+#ifdef ICE_CPP11_MAPPING
+    std::list<std::function<void(const Ice::PropertyDict&)>> _updateCallbacks;
+#else
     std::vector<Ice::PropertiesAdminUpdateCallbackPtr> _updateCallbacks;
+#endif
+
 };
-typedef IceUtil::Handle<PropertiesAdminI> PropertiesAdminIPtr;
+ICE_DEFINE_PTR(PropertiesAdminIPtr, PropertiesAdminI);
 
 }
 

data/ext/ice/cpp/src/Ice/PropertiesF.cpp

@@ -1,13 +1,8 @@
-// **********************************************************************
 //
-// 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.
 //
-// **********************************************************************
-//
-// Ice version 3.6.5
+// Ice version 3.7.4
 //
 // <auto-generated>
 //
@@ -23,23 +18,46 @@
 #endif
 #include <Ice/PropertiesF.h>
 #include <IceUtil/PushDisableWarnings.h>
-#include <Ice/BasicStream.h>
-#include <IceUtil/Iterator.h>
+#include <Ice/InputStream.h>
+#include <Ice/OutputStream.h>
 #include <IceUtil/PopDisableWarnings.h>
 
+#if defined(_MSC_VER)
+#   pragma warning(disable:4458) // declaration of ... hides class member
+#elif defined(__clang__)
+#   pragma clang diagnostic ignored "-Wshadow"
+#elif defined(__GNUC__)
+#   pragma GCC diagnostic ignored "-Wshadow"
+#endif
+
 #ifndef ICE_IGNORE_VERSION
-#   if ICE_INT_VERSION / 100 != 306
+#   if ICE_INT_VERSION / 100 != 307
 #       error Ice version mismatch!
 #   endif
-#   if ICE_INT_VERSION % 100 > 50
+#   if ICE_INT_VERSION % 100 >= 50
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 4
 #       error Ice patch level mismatch!
 #   endif
 #endif
 
+#ifdef ICE_CPP11_MAPPING // C++11 mapping
+
 namespace
 {
 
 }
+
+#else // C++98 mapping
+
+namespace
+{
+
+}
+
+namespace Ice
+{
+}
+
+#endif

data/ext/ice/cpp/src/Ice/PropertiesI.cpp

@@ -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.
-//
-// **********************************************************************
 
 #include <Ice/PropertiesI.h>
 #include <IceUtil/StringUtil.h>
@@ -16,13 +11,14 @@
 #include <Ice/Logger.h>
 #include <Ice/LoggerUtil.h>
 #include <Ice/Communicator.h>
+#include <fstream>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
 string
-Ice::PropertiesI::getProperty(const string& key)
+Ice::PropertiesI::getProperty(const string& key) ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
 
@@ -39,7 +35,7 @@ Ice::PropertiesI::getProperty(const string& key)
 }
 
 string
-Ice::PropertiesI::getPropertyWithDefault(const string& key, const string& value)
+Ice::PropertiesI::getPropertyWithDefault(const string& key, const string& value) ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
 
@@ -56,13 +52,13 @@ Ice::PropertiesI::getPropertyWithDefault(const string& key, const string& value)
 }
 
 Int
-Ice::PropertiesI::getPropertyAsInt(const string& key)
+Ice::PropertiesI::getPropertyAsInt(const string& key) ICE_NOEXCEPT
 {
     return getPropertyAsIntWithDefault(key, 0);
 }
 
 Int
-Ice::PropertiesI::getPropertyAsIntWithDefault(const string& key, Int value)
+Ice::PropertiesI::getPropertyAsIntWithDefault(const string& key, Int value) ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
 
@@ -84,13 +80,13 @@ Ice::PropertiesI::getPropertyAsIntWithDefault(const string& key, Int value)
 }
 
 Ice::StringSeq
-Ice::PropertiesI::getPropertyAsList(const string& key)
+Ice::PropertiesI::getPropertyAsList(const string& key) ICE_NOEXCEPT
 {
     return getPropertyAsListWithDefault(key, StringSeq());
 }
 
 Ice::StringSeq
-Ice::PropertiesI::getPropertyAsListWithDefault(const string& key, const StringSeq& value)
+Ice::PropertiesI::getPropertyAsListWithDefault(const string& key, const StringSeq& value) ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
 
@@ -117,9 +113,8 @@ Ice::PropertiesI::getPropertyAsListWithDefault(const string& key, const StringSe
     }
 }
 
-
 PropertyDict
-Ice::PropertiesI::getPropertiesForPrefix(const string& prefix)
+Ice::PropertiesI::getPropertiesForPrefix(const string& prefix) ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
 
@@ -235,7 +230,7 @@ Ice::PropertiesI::setProperty(const string& key, const string& value)
 }
 
 StringSeq
-Ice::PropertiesI::getCommandLineOptions()
+Ice::PropertiesI::getCommandLineOptions() ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
 
@@ -295,20 +290,22 @@ Ice::PropertiesI::parseIceCommandLineOptions(const StringSeq& options)
 void
 Ice::PropertiesI::load(const std::string& file)
 {
+    StringConverterPtr stringConverter = getProcessStringConverter();
+
 //
-// Metro style applications cannot access Windows registry.
+// UWP applications cannot access Windows registry.
 //
-#if defined (_WIN32) && !defined(ICE_OS_WINRT)
-    if(file.find("HKLM\\") == 0)
+#if defined (_WIN32) && !defined(ICE_OS_UWP)
+    if(file.find("HKCU\\") == 0 || file.find("HKLM\\") == 0)
     {
+        HKEY key = file.find("HKCU\\") == 0 ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
         HKEY iceKey;
-        const wstring keyName = IceUtil::stringToWstring(file, _converter).substr(5).c_str();
+        const wstring keyName = stringToWstring(file, stringConverter).substr(file.find("\\") + 1).c_str();
         LONG err;
-        if((err = RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyName.c_str(), 0, KEY_QUERY_VALUE, &iceKey)) != ERROR_SUCCESS)
+        if((err = RegOpenKeyExW(key, keyName.c_str(), 0, KEY_QUERY_VALUE, &iceKey)) != ERROR_SUCCESS)
         {
-            InitializationException ex(__FILE__, __LINE__);
-            ex.reason = "could not open Windows registry key `" + file + "':\n" + IceUtilInternal::errorToString(err);
-            throw ex;
+            throw InitializationException(__FILE__, __LINE__, "could not open Windows registry key `" + file + "':\n" +
+                                          IceUtilInternal::errorToString(err));
         }
 
         DWORD maxNameSize; // Size in characters not including terminating null character.
@@ -316,14 +313,12 @@ Ice::PropertiesI::load(const std::string& file)
         DWORD numValues;
         try
         {
-            err = RegQueryInfoKey(iceKey, NULL, NULL, NULL, NULL, NULL, NULL, &numValues, &maxNameSize, &maxDataSize,
-                                  NULL, NULL);
+            err = RegQueryInfoKey(iceKey, ICE_NULLPTR, ICE_NULLPTR, ICE_NULLPTR, ICE_NULLPTR, ICE_NULLPTR, ICE_NULLPTR,
+                                  &numValues, &maxNameSize, &maxDataSize, ICE_NULLPTR, ICE_NULLPTR);
             if(err != ERROR_SUCCESS)
             {
-                InitializationException ex(__FILE__, __LINE__);
-                ex.reason = "could not open Windows registry key `" + file + "':\n";
-                ex.reason += IceUtilInternal::errorToString(err);
-                throw ex;
+                throw InitializationException(__FILE__, __LINE__, "could not open Windows registry key `" + file +
+                                              "':\n" + IceUtilInternal::errorToString(err));
             }
 
             for(DWORD i = 0; i < numValues; ++i)
@@ -333,7 +328,7 @@ Ice::PropertiesI::load(const std::string& file)
                 DWORD keyType;
                 DWORD nameBufSize = static_cast<DWORD>(nameBuf.size());
                 DWORD dataBufSize = static_cast<DWORD>(dataBuf.size());
-                err = RegEnumValueW(iceKey, i, &nameBuf[0], &nameBufSize, NULL, &keyType, &dataBuf[0], &dataBufSize);
+                err = RegEnumValueW(iceKey, i, &nameBuf[0], &nameBufSize, ICE_NULLPTR, &keyType, &dataBuf[0], &dataBufSize);
                 if(err != ERROR_SUCCESS || nameBufSize == 0)
                 {
                     ostringstream os;
@@ -349,8 +344,8 @@ Ice::PropertiesI::load(const std::string& file)
                     getProcessLogger()->warning(os.str());
                     continue;
                 }
-                string name = IceUtil::wstringToString(
-                    wstring(reinterpret_cast<wchar_t*>(&nameBuf[0]), nameBufSize), _converter);
+                string name = wstringToString(
+                    wstring(reinterpret_cast<wchar_t*>(&nameBuf[0]), nameBufSize), stringConverter);
                 if(keyType != REG_SZ && keyType != REG_EXPAND_SZ)
                 {
                     ostringstream os;
@@ -363,7 +358,7 @@ Ice::PropertiesI::load(const std::string& file)
                 wstring valueW = wstring(reinterpret_cast<wchar_t*>(&dataBuf[0]), (dataBufSize / sizeof(wchar_t)) - 1);
                 if(keyType == REG_SZ)
                 {
-                    value = IceUtil::wstringToString(valueW, _converter);
+                    value = wstringToString(valueW, stringConverter);
                 }
                 else // keyType == REG_EXPAND_SZ
                 {
@@ -383,7 +378,7 @@ Ice::PropertiesI::load(const std::string& file)
                             continue;
                         }
                     }
-                    value = IceUtil::wstringToString(wstring(&expandedValue[0], sz -1), _converter);
+                    value = wstringToString(wstring(&expandedValue[0], sz -1), stringConverter);
                 }
                 setProperty(name, value);
             }
@@ -398,13 +393,10 @@ Ice::PropertiesI::load(const std::string& file)
     else
 #endif
     {
-        IceUtilInternal::ifstream in(file);
+        ifstream in(IceUtilInternal::streamFilename(file).c_str());
         if(!in)
         {
-            FileException ex(__FILE__, __LINE__);
-            ex.path = file;
-            ex.error = getSystemErrno();
-            throw ex;
+            throw FileException(__FILE__, __LINE__, getSystemErrno(), file);
         }
 
         string line;
@@ -418,24 +410,24 @@ Ice::PropertiesI::load(const std::string& file)
             {
                 const unsigned char UTF8_BOM[3] = {0xEF, 0xBB, 0xBF};
                 if(line.size() >= 3 &&
-                   static_cast<const unsigned char>(line[0]) == UTF8_BOM[0] &&
-                   static_cast<const unsigned char>(line[1]) == UTF8_BOM[1] &&
-                   static_cast<const unsigned char>(line[2]) == UTF8_BOM[2])
+                   static_cast<unsigned char>(line[0]) == UTF8_BOM[0] &&
+                   static_cast<unsigned char>(line[1]) == UTF8_BOM[1] &&
+                   static_cast<unsigned char>(line[2]) == UTF8_BOM[2])
                 {
                     line = line.substr(3);
                 }
                 firstLine = false;
             }
-            parseLine(line, _converter);
+            parseLine(line, stringConverter);
         }
     }
 }
 
 PropertiesPtr
-Ice::PropertiesI::clone()
+Ice::PropertiesI::clone() ICE_NOEXCEPT
 {
     IceUtil::Mutex::Lock sync(*this);
-    return new PropertiesI(this);
+    return ICE_MAKE_SHARED(PropertiesI, this);
 }
 
 set<string>
@@ -454,18 +446,15 @@ Ice::PropertiesI::getUnusedProperties()
 }
 
 Ice::PropertiesI::PropertiesI(const PropertiesI* p) :
-    _properties(p->_properties),
-    _converter(p->_converter)
+    _properties(p->_properties)
 {
 }
 
-Ice::PropertiesI::PropertiesI(const IceUtil::StringConverterPtr& converter) :
-    _converter(converter)
+Ice::PropertiesI::PropertiesI()
 {
 }
 
-Ice::PropertiesI::PropertiesI(StringSeq& args, const PropertiesPtr& defaults, const IceUtil::StringConverterPtr& converter) :
-    _converter(converter)
+Ice::PropertiesI::PropertiesI(StringSeq& args, const PropertiesPtr& defaults)
 {
     if(defaults != 0)
     {
@@ -536,7 +525,7 @@ Ice::PropertiesI::PropertiesI(StringSeq& args, const PropertiesPtr& defaults, co
 }
 
 void
-Ice::PropertiesI::parseLine(const string& line, const IceUtil::StringConverterPtr& converter)
+Ice::PropertiesI::parseLine(const string& line, const StringConverterPtr& converter)
 {
     string key;
     string value;
@@ -701,8 +690,8 @@ Ice::PropertiesI::parseLine(const string& line, const IceUtil::StringConverterPt
         return;
     }
 
-    key = IceUtil::UTF8ToNative(key, converter);
-    value = IceUtil::UTF8ToNative(value, converter);
+    key = UTF8ToNative(key, converter);
+    value = UTF8ToNative(value, converter);
 
     setProperty(key, value);
 }
@@ -711,9 +700,9 @@ void
 Ice::PropertiesI::loadConfig()
 {
     string value = getProperty("Ice.Config");
-#ifndef ICE_OS_WINRT
+#ifndef ICE_OS_UWP
     //
-    // WinRT cannot access environment variables
+    // UWP cannot access environment variables
     //
     if(value.empty() || value == "1")
     {
@@ -727,7 +716,7 @@ Ice::PropertiesI::loadConfig()
         }
         if(ret > 0)
         {
-            value = IceUtil::wstringToString(wstring(&v[0], ret), _converter);
+            value = wstringToString(wstring(&v[0], ret), getProcessStringConverter());
         }
         else
         {