zeroc-ice 3.7.11 → 3.8.1

data/dist/ice/cpp/src/Ice/DefaultsAndOverrides.cpp

@@ -1,159 +1,81 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/DefaultsAndOverrides.h>
-#include <Ice/Properties.h>
-#include <Ice/LoggerUtil.h>
-#include <Ice/LocalException.h>
+#include "DefaultsAndOverrides.h"
+#include "Ice/LocalExceptions.h"
+#include "Ice/Properties.h"
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-IceUtil::Shared* IceInternal::upCast(DefaultsAndOverrides* p) { return p; }
-
-IceInternal::DefaultsAndOverrides::DefaultsAndOverrides(const PropertiesPtr& properties, const LoggerPtr& logger) :
-    overrideTimeout(false),
-    overrideTimeoutValue(-1),
-    overrideConnectTimeout(false),
-    overrideConnectTimeoutValue(-1),
-    overrideCloseTimeout(false),
-    overrideCloseTimeoutValue(-1),
-    overrideCompress(false),
-    overrideCompressValue(false),
-    overrideSecure(false),
-    overrideSecureValue(false)
+IceInternal::DefaultsAndOverrides::DefaultsAndOverrides(const PropertiesPtr& properties) : overrideCompress(nullopt)
 {
-    const_cast<string&>(defaultProtocol) = properties->getPropertyWithDefault("Ice.Default.Protocol", "tcp");
+    const_cast<string&>(defaultProtocol) = properties->getIceProperty("Ice.Default.Protocol");
 
-    const_cast<string&>(defaultHost) = properties->getProperty("Ice.Default.Host");
+    const_cast<string&>(defaultHost) = properties->getIceProperty("Ice.Default.Host");
 
     string value;
 
-    value = properties->getProperty("Ice.Default.SourceAddress");
-    if(!value.empty())
+    value = properties->getIceProperty("Ice.Default.SourceAddress");
+    if (!value.empty())
     {
         const_cast<Address&>(defaultSourceAddress) = getNumericAddress(value);
-        if(!isAddressValid(defaultSourceAddress))
-        {
-            throw InitializationException(__FILE__, __LINE__, "invalid IP address set for Ice.Default.SourceAddress: `" +
-                                          value + "'");
-        }
-    }
-
-    value = properties->getProperty("Ice.Override.Timeout");
-    if(!value.empty())
-    {
-        const_cast<bool&>(overrideTimeout) = true;
-        const_cast<Int&>(overrideTimeoutValue) = properties->getPropertyAsInt("Ice.Override.Timeout");
-        if(overrideTimeoutValue < 1 && overrideTimeoutValue != -1)
+        if (!isAddressValid(defaultSourceAddress))
         {
-            const_cast<Int&>(overrideTimeoutValue) = -1;
-            Warning out(logger);
-            out << "invalid value for Ice.Override.Timeout `" << properties->getProperty("Ice.Override.Timeout")
-                << "': defaulting to -1";
+            throw InitializationException(
+                __FILE__,
+                __LINE__,
+                "invalid IP address set for Ice.Default.SourceAddress: '" + value + "'");
         }
     }
 
-    value = properties->getProperty("Ice.Override.ConnectTimeout");
-    if(!value.empty())
+    value = properties->getIceProperty("Ice.Override.Compress");
+    if (!value.empty())
     {
-        const_cast<bool&>(overrideConnectTimeout) = true;
-        const_cast<Int&>(overrideConnectTimeoutValue) = properties->getPropertyAsInt("Ice.Override.ConnectTimeout");
-        if(overrideConnectTimeoutValue < 1 && overrideConnectTimeoutValue != -1)
-        {
-            const_cast<Int&>(overrideConnectTimeoutValue) = -1;
-            Warning out(logger);
-            out << "invalid value for Ice.Override.ConnectTimeout `"
-                << properties->getProperty("Ice.Override.ConnectTimeout") << "': defaulting to -1";
-        }
-    }
-
-    value = properties->getProperty("Ice.Override.CloseTimeout");
-    if(!value.empty())
-    {
-        const_cast<bool&>(overrideCloseTimeout) = true;
-        const_cast<Int&>(overrideCloseTimeoutValue) = properties->getPropertyAsInt("Ice.Override.CloseTimeout");
-        if(overrideCloseTimeoutValue < 1 && overrideCloseTimeoutValue != -1)
-        {
-            const_cast<Int&>(overrideCloseTimeoutValue) = -1;
-            Warning out(logger);
-            out << "invalid value for Ice.Override.CloseTimeout `"
-                << properties->getProperty("Ice.Override.CloseTimeout") << "': defaulting to -1";
-        }
-    }
-
-    value = properties->getProperty("Ice.Override.Compress");
-    if(!value.empty())
-    {
-        const_cast<bool&>(overrideCompress) = true;
-        const_cast<bool&>(overrideCompressValue) = properties->getPropertyAsInt("Ice.Override.Compress") > 0;
-    }
-
-    value = properties->getProperty("Ice.Override.Secure");
-    if(!value.empty())
-    {
-        const_cast<bool&>(overrideSecure) = true;
-        const_cast<bool&>(overrideSecureValue) = properties->getPropertyAsInt("Ice.Override.Secure") > 0;
+        const_cast<optional<bool>&>(overrideCompress) = properties->getIcePropertyAsInt("Ice.Override.Compress") > 0;
     }
 
     const_cast<bool&>(defaultCollocationOptimization) =
-        properties->getPropertyAsIntWithDefault("Ice.Default.CollocationOptimized", 1) > 0;
+        properties->getIcePropertyAsInt("Ice.Default.CollocationOptimized") > 0;
 
-    value = properties->getPropertyWithDefault("Ice.Default.EndpointSelection", "Random");
-    if(value == "Random")
+    value = properties->getIceProperty("Ice.Default.EndpointSelection");
+    if (value == "Random")
     {
-        defaultEndpointSelection = ICE_ENUM(EndpointSelectionType, Random);
+        defaultEndpointSelection = EndpointSelectionType::Random;
     }
-    else if(value == "Ordered")
+    else if (value == "Ordered")
     {
-        defaultEndpointSelection = ICE_ENUM(EndpointSelectionType, Ordered);
+        defaultEndpointSelection = EndpointSelectionType::Ordered;
     }
     else
     {
-        throw EndpointSelectionTypeParseException(__FILE__, __LINE__, "illegal value `" + value +
-                                                  "'; expected `Random' or `Ordered'");
+        throw ParseException(__FILE__, __LINE__, "illegal value '" + value + "'; expected 'Random' or 'Ordered'");
     }
 
-    const_cast<int&>(defaultTimeout) =
-        properties->getPropertyAsIntWithDefault("Ice.Default.Timeout", 60000);
-    if(defaultTimeout < 1 && defaultTimeout != -1)
+    const_cast<chrono::milliseconds&>(defaultInvocationTimeout) =
+        chrono::milliseconds(properties->getIcePropertyAsInt("Ice.Default.InvocationTimeout"));
+    if (defaultInvocationTimeout.count() < 1 && defaultInvocationTimeout.count() != -1)
     {
-        const_cast<Int&>(defaultTimeout) = 60000;
-        Warning out(logger);
-        out << "invalid value for Ice.Default.Timeout `" << properties->getProperty("Ice.Default.Timeout")
-            << "': defaulting to 60000";
+        throw InitializationException{
+            __FILE__,
+            __LINE__,
+            "invalid value for Ice.Default.InvocationTimeout: " + to_string(defaultInvocationTimeout.count())};
     }
 
-    const_cast<int&>(defaultInvocationTimeout) =
-        properties->getPropertyAsIntWithDefault("Ice.Default.InvocationTimeout", -1);
-    if(defaultInvocationTimeout < 1 && defaultInvocationTimeout != -1 && defaultInvocationTimeout != -2)
+    const_cast<chrono::seconds&>(defaultLocatorCacheTimeout) =
+        chrono::seconds(properties->getIcePropertyAsInt("Ice.Default.LocatorCacheTimeout"));
+    if (defaultLocatorCacheTimeout.count() < -1)
     {
-        const_cast<Int&>(defaultInvocationTimeout) = -1;
-        Warning out(logger);
-        out << "invalid value for Ice.Default.InvocationTimeout `"
-            << properties->getProperty("Ice.Default.InvocationTimeout") << "': defaulting to -1";
+        throw InitializationException{
+            __FILE__,
+            __LINE__,
+            "invalid value for Ice.Default.LocatorCacheTimeout: " + to_string(defaultLocatorCacheTimeout.count())};
     }
 
-    const_cast<int&>(defaultLocatorCacheTimeout) =
-        properties->getPropertyAsIntWithDefault("Ice.Default.LocatorCacheTimeout", -1);
-    if(defaultLocatorCacheTimeout < -1)
-    {
-        const_cast<Int&>(defaultLocatorCacheTimeout) = -1;
-        Warning out(logger);
-        out << "invalid value for Ice.Default.LocatorCacheTimeout `"
-            << properties->getProperty("Ice.Default.LocatorCacheTimeout") << "': defaulting to -1";
-    }
-
-    const_cast<bool&>(defaultPreferSecure) =
-        properties->getPropertyAsIntWithDefault("Ice.Default.PreferSecure", 0) > 0;
-
-    value = properties->getPropertyWithDefault("Ice.Default.EncodingVersion", encodingVersionToString(currentEncoding));
+    value = properties->getIceProperty("Ice.Default.EncodingVersion");
     defaultEncoding = stringToEncodingVersion(value);
     checkSupportedEncoding(defaultEncoding);
 
-    bool slicedFormat = properties->getPropertyAsIntWithDefault("Ice.Default.SlicedFormat", 0) > 0;
-    const_cast<FormatType&>(defaultFormat) = slicedFormat ?
-        ICE_ENUM(FormatType, SlicedFormat) : ICE_ENUM(FormatType, CompactFormat);
+    bool slicedFormat = properties->getIcePropertyAsInt("Ice.Default.SlicedFormat") > 0;
+    const_cast<FormatType&>(defaultFormat) = slicedFormat ? FormatType::SlicedFormat : FormatType::CompactFormat;
 }

data/dist/ice/cpp/src/Ice/DefaultsAndOverrides.h

@@ -1,52 +1,38 @@
 
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_DEFAULTS_AND_OVERRIDES_H
 #define ICE_DEFAULTS_AND_OVERRIDES_H
 
-#include <IceUtil/Shared.h>
-#include <Ice/DefaultsAndOverridesF.h>
-#include <Ice/PropertiesF.h>
-#include <Ice/Endpoint.h>
-#include <Ice/EndpointTypes.h>
-#include <Ice/Format.h>
-#include <Ice/Network.h>
+#include "DefaultsAndOverridesF.h"
+#include "Ice/Endpoint.h"
+#include "Ice/EndpointSelectionType.h"
+#include "Ice/EndpointTypes.h"
+#include "Ice/Format.h"
+#include "Ice/PropertiesF.h"
+#include "Network.h"
 
-namespace IceInternal
-{
+#include <chrono>
 
-class DefaultsAndOverrides : public ::IceUtil::Shared
+namespace IceInternal
 {
-public:
-
-    DefaultsAndOverrides(const ::Ice::PropertiesPtr&, const ::Ice::LoggerPtr&);
-
-    std::string defaultHost;
-    Address defaultSourceAddress;
-    std::string defaultProtocol;
-    bool defaultCollocationOptimization;
-    Ice::EndpointSelectionType defaultEndpointSelection;
-    int defaultTimeout;
-    int defaultInvocationTimeout;
-    int defaultLocatorCacheTimeout;
-    bool defaultPreferSecure;
-    Ice::EncodingVersion defaultEncoding;
-    Ice::FormatType defaultFormat;
-
-    bool overrideTimeout;
-    Ice::Int overrideTimeoutValue;
-    bool overrideConnectTimeout;
-    Ice::Int overrideConnectTimeoutValue;
-    bool overrideCloseTimeout;
-    Ice::Int overrideCloseTimeoutValue;
-    bool overrideCompress;
-    bool overrideCompressValue;
-    bool overrideSecure;
-    bool overrideSecureValue;
-};
-
+    class DefaultsAndOverrides
+    {
+    public:
+        DefaultsAndOverrides(const Ice::PropertiesPtr&);
+
+        std::string defaultHost;
+        Address defaultSourceAddress;
+        std::string defaultProtocol;
+        bool defaultCollocationOptimization;
+        Ice::EndpointSelectionType defaultEndpointSelection;
+        std::chrono::milliseconds defaultInvocationTimeout;
+        std::chrono::seconds defaultLocatorCacheTimeout;
+        Ice::EncodingVersion defaultEncoding;
+        Ice::FormatType defaultFormat;
+
+        std::optional<bool> overrideCompress;
+    };
 }
 
 #endif

data/dist/ice/cpp/src/Ice/DefaultsAndOverridesF.h

@@ -1,21 +1,14 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_DEFAULTS_AND_OVERRIDES_F_H
 #define ICE_DEFAULTS_AND_OVERRIDES_F_H
 
-#include <IceUtil/Shared.h>
-
-#include <Ice/Handle.h>
+#include <memory>
 
 namespace IceInternal
 {
-
-class DefaultsAndOverrides;
-IceUtil::Shared* upCast(DefaultsAndOverrides*);
-typedef Handle<DefaultsAndOverrides> DefaultsAndOverridesPtr;
-
+    class DefaultsAndOverrides;
+    using DefaultsAndOverridesPtr = std::shared_ptr<DefaultsAndOverrides>;
 }
 
 #endif

data/dist/ice/cpp/src/Ice/Demangle.cpp

@@ -0,0 +1,26 @@
+// Copyright (c) ZeroC, Inc.
+
+#include "Ice/Demangle.h"
+
+#if defined(__GNUC__) || defined(__clang__)
+#    include <cstdlib>
+#    include <cxxabi.h>
+#endif
+
+using namespace std;
+
+string
+IceInternal::demangle(const char* name)
+{
+#if defined(__GNUC__) || defined(__clang__)
+    int status;
+    char* demangled = abi::__cxa_demangle(name, nullptr, nullptr, &status);
+    if (status == 0) // success
+    {
+        string result{demangled};
+        std::free(demangled);
+        return result;
+    }
+#endif
+    return name; // keep the original name
+}

data/dist/ice/cpp/src/Ice/DisableWarnings.h

@@ -0,0 +1,31 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_DISABLE_WARNINGS_H
+#define ICE_DISABLE_WARNINGS_H
+
+// Disable mostly deprecated warnings.
+
+//
+// Microsoft Visual C++
+//
+#if defined(_MSC_VER)
+#    define _CRT_SECURE_NO_DEPRECATE 1 // C4996 '<C function>' was declared deprecated
+#    pragma warning(disable : 4996)    // C4996 '<function>' was declared deprecated
+#    pragma warning(disable : 4800)    // C4800 forcing value to bool 'true' or 'false' (performance warning)
+#endif
+
+//
+// GCC
+//
+#if defined(__GNUC__)
+#    pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+//
+// Clang
+//
+#if defined(__clang__)
+#    pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#endif
+
+#endif

data/dist/ice/cpp/src/Ice/DynamicLibrary.cpp

@@ -1,49 +1,23 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
-#include <Ice/DynamicLibrary.h>
-#include <IceUtil/StringUtil.h>
-#include <Ice/StringConverter.h>
+#include "DynamicLibrary.h"
+#include "Ice/StringConverter.h"
+#include "Ice/StringUtil.h"
 
-#ifndef _WIN32
-#   include <dlfcn.h>
-#endif
+#include <cassert>
+#include <sstream>
 
-#if defined(ICE_CPP11) && defined(__GNUC__) && (__GNUC__ < 6) && defined(__GLIBCXX__)
-#   define ICE_LIBSUFFIX "++11"
+#ifndef _WIN32
+#    include <dlfcn.h>
 #endif
 
 using namespace Ice;
 using namespace IceInternal;
 using namespace std;
 
-IceUtil::Shared* IceInternal::upCast(DynamicLibrary* p) { return p; }
-IceUtil::Shared* IceInternal::upCast(DynamicLibraryList* p) { return p; }
-
-IceInternal::DynamicLibrary::DynamicLibrary() :
-    _hnd(0)
-{
-}
-
-IceInternal::DynamicLibrary::~DynamicLibrary()
-{
-    /*
-     * Closing the library here can cause a crash at program exit if
-     * the application holds references to library resources in global
-     * or static variables. Instead, we let the process discard the
-     * library.
-     *
-    if(_hnd != 0)
-    {
-#ifdef _WIN32
-        FreeLibrary(_hnd);
-#else
-        dlclose(_hnd);
-#endif
-    }
-    */
-}
+// Closing the library here can cause a crash at program exit if the application holds references to library resources
+// in global or static variables. Instead, we let the process discard the library.
+IceInternal::DynamicLibrary::~DynamicLibrary() = default;
 
 IceInternal::DynamicLibrary::symbol_type
 IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIceVersion)
@@ -52,8 +26,8 @@ IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIc
 
 #ifdef _WIN32
     const string driveLetters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    if(colon == 1 && driveLetters.find(entryPoint[0]) != string::npos &&
-       (entryPoint[2] == '\\' || entryPoint[2] == '/'))
+    if (colon == 1 && driveLetters.find(entryPoint[0]) != string::npos &&
+        (entryPoint[2] == '\\' || entryPoint[2] == '/'))
     {
         //
         // The only colon we found is in the drive specification, as in "C:\MyDir".
@@ -63,10 +37,10 @@ IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIc
     }
 #endif
 
-    if(colon == string::npos || colon == entryPoint.size() - 1)
+    if (colon == string::npos || colon == entryPoint.size() - 1)
     {
-        _err = "invalid entry point format `" + entryPoint + "'";
-        return 0;
+        _err = "invalid entry point format '" + entryPoint + "'";
+        return nullptr;
     }
 
     string libSpec = entryPoint.substr(0, colon);
@@ -78,31 +52,28 @@ IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIc
 #else
     string::size_type separator = libSpec.rfind('/');
 #endif
-    if(separator != string::npos)
+    if (separator != string::npos)
     {
         libPath = libSpec.substr(0, separator + 1);
         libSpec = libSpec.substr(separator + 1);
     }
 
     string::size_type comma = libSpec.find(',');
-    if(comma == string::npos)
+    if (comma == string::npos)
     {
         libName = libSpec;
-#  if defined(ICE_CPP11_MAPPING) && !defined(_WIN32)
-        libName += "++11";
-#  endif
-        if(useIceVersion)
+        if (useIceVersion)
         {
             int majorVersion = (ICE_INT_VERSION / 10000);
             int minorVersion = (ICE_INT_VERSION / 100) - majorVersion * 100;
             int patchVersion = ICE_INT_VERSION % 100;
             ostringstream os;
             os << majorVersion * 10 + minorVersion;
-            if(patchVersion >= 60)
+            if (patchVersion >= 60)
             {
                 os << 'b' << (patchVersion - 60);
             }
-            else if(patchVersion >= 50)
+            else if (patchVersion >= 50)
             {
                 os << 'a' << (patchVersion - 50);
             }
@@ -111,15 +82,12 @@ IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIc
     }
     else
     {
-        if(comma == libSpec.size() - 1)
+        if (comma == libSpec.size() - 1)
         {
-            _err = "invalid entry point format `" + entryPoint + "'";
-            return 0;
+            _err = "invalid entry point format '" + entryPoint + "'";
+            return nullptr;
         }
         libName = libSpec.substr(0, comma);
-#  if defined(ICE_CPP11_MAPPING) && !defined(_WIN32)
-        libName += "++11";
-#  endif
         version = libSpec.substr(comma + 1);
     }
 
@@ -129,45 +97,24 @@ IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIc
     lib += libName;
     lib += version;
 
-#  ifdef ICE_CPP11_MAPPING
-    lib += "++11";
-#  endif
-
-#   if defined(_DEBUG) && !defined(__MINGW32__)
+#    if defined(_DEBUG)
     lib += 'd';
-#   endif
+#    endif
 
-#   ifdef COMPSUFFIX
+#    ifdef COMPSUFFIX
     lib += COMPSUFFIX;
-#   endif
+#    endif
 
     lib += ".dll";
 #elif defined(__APPLE__)
     lib += "lib" + libName;
-    if(!version.empty())
+    if (!version.empty())
     {
         lib += "." + version;
     }
-#elif defined(__hpux)
-    lib += "lib" + libName;
-    if(!version.empty())
-    {
-        lib += "." + version;
-    }
-    else
-    {
-        lib += ".sl";
-    }
-#elif defined(_AIX)
-    lib += "lib" + libName + ".a(lib" + libName + ".so";
-    if(!version.empty())
-    {
-        lib += "." + version;
-    }
-    lib += ")";
 #else
     lib += "lib" + libName + ".so";
-    if(!version.empty())
+    if (!version.empty())
     {
         lib += "." + version;
     }
@@ -178,24 +125,24 @@ IceInternal::DynamicLibrary::loadEntryPoint(const string& entryPoint, bool useIc
     // On macOS fallback to .so and .bundle extensions, if the default
     // .dylib fails.
     //
-    if(!load(lib + ".dylib"))
+    if (!load(lib + ".dylib"))
     {
         string errMsg = _err;
-        if(!load(lib + ".so"))
+        if (!load(lib + ".so"))
         {
             errMsg += "; " + _err;
-            if(!load(lib + ".bundle"))
+            if (!load(lib + ".bundle"))
             {
                 _err = errMsg + "; " + _err;
-                return 0;
+                return nullptr;
             }
         }
         _err = "";
     }
 #else
-    if(!load(lib))
+    if (!load(lib))
     {
-        return 0;
+        return nullptr;
     }
 #endif
 
@@ -213,51 +160,47 @@ IceInternal::DynamicLibrary::load(const string& lib)
     _hnd = LoadLibraryW(stringToWstring(lib, getProcessStringConverter()).c_str());
 #else
     int flags = RTLD_NOW | RTLD_GLOBAL;
-#ifdef _AIX
-    flags |= RTLD_MEMBER;
-#endif
-
     _hnd = dlopen(lib.c_str(), flags);
 #endif
-    if(_hnd == 0)
+    if (_hnd == nullptr)
     {
         //
         // Remember the most recent error in _err.
         //
 #if defined(_WIN32)
-        _err = "LoadLibraryW on `" + lib + "' failed with `" + IceUtilInternal::lastErrorToString() + "'";
+        _err = "LoadLibraryW on '" + lib + "' failed with '" + IceInternal::lastErrorToString() + "'";
 #else
         const char* err = dlerror();
-        if(err)
+        if (err)
         {
             _err = err;
         }
 #endif
     }
 
-    return _hnd != 0;
+    return _hnd != nullptr;
 }
 
 IceInternal::DynamicLibrary::symbol_type
 IceInternal::DynamicLibrary::getSymbol(const string& name)
 {
-    assert(_hnd != 0);
+    assert(_hnd != nullptr);
 #ifdef _WIN32
     symbol_type result = GetProcAddress(_hnd, name.c_str());
 #else
     symbol_type result = dlsym(_hnd, name.c_str());
 #endif
 
-    if(result == 0)
+    if (result == nullptr)
     {
         //
         // Remember the most recent error in _err.
         //
 #ifdef _WIN32
-        _err = "GetProcAddress for `" + name + "' failed with `" + IceUtilInternal::lastErrorToString() + "'";
+        _err = "GetProcAddress for '" + name + "' failed with '" + IceInternal::lastErrorToString() + "'";
 #else
         const char* err = dlerror();
-        if(err)
+        if (err)
         {
             _err = err;
         }
@@ -271,14 +214,3 @@ IceInternal::DynamicLibrary::getErrorMessage() const
 {
     return _err;
 }
-
-IceInternal::DynamicLibraryList::~DynamicLibraryList()
-{
-    // Out of line to avoid weak vtable
-}
-
-void
-IceInternal::DynamicLibraryList::add(const DynamicLibraryPtr& library)
-{
-    _libraries.push_back(library);
-}