zeroc-ice 3.6.5 → 3.7.0

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

@@ -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.
@@ -8,8 +8,10 @@
 // **********************************************************************
 
 #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 +23,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 +186,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());
+
+        // 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 p = callbacks.begin(); p != callbacks.end(); ++p)
+#endif
         {
             try
             {
+#ifdef ICE_CPP11_MAPPING
+                cb(changes);
+#else
                 (*p)->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 +265,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,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.
@@ -16,29 +16,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,13 @@
 // **********************************************************************
 //
-// 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.
 //
 // **********************************************************************
 //
-// Ice version 3.6.5
+// Ice version 3.7.0
 //
 // <auto-generated>
 //
@@ -23,23 +23,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
 #       error Beta header file detected
 #   endif
-#   if ICE_INT_VERSION % 100 < 5
+#   if ICE_INT_VERSION % 100 < 0
 #       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,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.
@@ -16,6 +16,7 @@
 #include <Ice/Logger.h>
 #include <Ice/LoggerUtil.h>
 #include <Ice/Communicator.h>
+#include <fstream>
 
 using namespace std;
 using namespace Ice;
@@ -117,7 +118,6 @@ Ice::PropertiesI::getPropertyAsListWithDefault(const string& key, const StringSe
     }
 }
 
-
 PropertyDict
 Ice::PropertiesI::getPropertiesForPrefix(const string& prefix)
 {
@@ -295,14 +295,16 @@ Ice::PropertiesI::parseIceCommandLineOptions(const StringSeq& options)
 void
 Ice::PropertiesI::load(const std::string& file)
 {
+    StringConverterPtr stringConverter = getProcessStringConverter();
+
 //
 // Metro style applications cannot access Windows registry.
 //
-#if defined (_WIN32) && !defined(ICE_OS_WINRT)
+#if defined (_WIN32) && !defined(ICE_OS_UWP)
     if(file.find("HKLM\\") == 0)
     {
         HKEY iceKey;
-        const wstring keyName = IceUtil::stringToWstring(file, _converter).substr(5).c_str();
+        const wstring keyName = stringToWstring(file, stringConverter).substr(5).c_str();
         LONG err;
         if((err = RegOpenKeyExW(HKEY_LOCAL_MACHINE, keyName.c_str(), 0, KEY_QUERY_VALUE, &iceKey)) != ERROR_SUCCESS)
         {
@@ -316,8 +318,8 @@ 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__);
@@ -333,7 +335,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 +351,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 +365,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 +385,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,7 +400,7 @@ 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__);
@@ -426,7 +428,7 @@ Ice::PropertiesI::load(const std::string& file)
                 }
                 firstLine = false;
             }
-            parseLine(line, _converter);
+            parseLine(line, stringConverter);
         }
     }
 }
@@ -435,7 +437,7 @@ PropertiesPtr
 Ice::PropertiesI::clone()
 {
     IceUtil::Mutex::Lock sync(*this);
-    return new PropertiesI(this);
+    return ICE_MAKE_SHARED(PropertiesI, this);
 }
 
 set<string>
@@ -454,18 +456,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 +535,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 +700,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 +710,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 +726,7 @@ Ice::PropertiesI::loadConfig()
         }
         if(ret > 0)
         {
-            value = IceUtil::wstringToString(wstring(&v[0], ret), _converter);
+            value = wstringToString(wstring(&v[0], ret), getProcessStringConverter());
         }
         else
         {