zeroc-ice 3.7.11 → 3.8.1

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

@@ -1,138 +1,132 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef _WIN32
 
-#include <Ice/SysLoggerI.h>
-#include <Ice/LocalException.h>
-#include <syslog.h>
+#    include "SysLoggerI.h"
+#    include "Ice/LocalExceptions.h"
+#    include <syslog.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-Ice::SysLoggerI::SysLoggerI(const string& prefix, const string& facilityString) :
-    _facility(0),
-    _prefix(prefix)
+Ice::SysLoggerI::SysLoggerI(string prefix, string_view facilityString) : _facility(0), _prefix(std::move(prefix))
 {
-    if(facilityString == "LOG_KERN")
+    if (facilityString == "LOG_KERN")
     {
         _facility = LOG_KERN;
     }
-    else if(facilityString == "LOG_USER")
+    else if (facilityString == "LOG_USER")
     {
         _facility = LOG_USER;
     }
-    else if(facilityString == "LOG_MAIL")
+    else if (facilityString == "LOG_MAIL")
     {
         _facility = LOG_MAIL;
     }
-    else if(facilityString == "LOG_DAEMON")
+    else if (facilityString == "LOG_DAEMON")
     {
         _facility = LOG_DAEMON;
     }
-    else if(facilityString == "LOG_AUTH")
+    else if (facilityString == "LOG_AUTH")
     {
         _facility = LOG_AUTH;
     }
-    else if(facilityString == "LOG_SYSLOG")
+    else if (facilityString == "LOG_SYSLOG")
     {
         _facility = LOG_SYSLOG;
     }
-    else if(facilityString == "LOG_LPR")
+    else if (facilityString == "LOG_LPR")
     {
         _facility = LOG_LPR;
     }
-    else if(facilityString == "LOG_NEWS")
+    else if (facilityString == "LOG_NEWS")
     {
         _facility = LOG_NEWS;
     }
-    else if(facilityString == "LOG_UUCP")
+    else if (facilityString == "LOG_UUCP")
     {
         _facility = LOG_UUCP;
     }
-    else if(facilityString == "LOG_CRON")
+    else if (facilityString == "LOG_CRON")
     {
         _facility = LOG_CRON;
     }
-#ifdef LOG_AUTHPRIV
-    else if(facilityString == "LOG_AUTHPRIV")
+#    ifdef LOG_AUTHPRIV
+    else if (facilityString == "LOG_AUTHPRIV")
     {
         _facility = LOG_AUTHPRIV;
     }
-#endif
-#ifdef LOG_FTP
-    else if(facilityString == "LOG_FTP")
+#    endif
+#    ifdef LOG_FTP
+    else if (facilityString == "LOG_FTP")
     {
         _facility = LOG_FTP;
     }
-#endif
-    else if(facilityString == "LOG_LOCAL0")
+#    endif
+    else if (facilityString == "LOG_LOCAL0")
     {
         _facility = LOG_LOCAL0;
     }
-    else if(facilityString == "LOG_LOCAL1")
+    else if (facilityString == "LOG_LOCAL1")
     {
         _facility = LOG_LOCAL1;
     }
-    else if(facilityString == "LOG_LOCAL2")
+    else if (facilityString == "LOG_LOCAL2")
     {
         _facility = LOG_LOCAL2;
     }
-    else if(facilityString == "LOG_LOCAL3")
+    else if (facilityString == "LOG_LOCAL3")
     {
         _facility = LOG_LOCAL3;
     }
-    else if(facilityString == "LOG_LOCAL4")
+    else if (facilityString == "LOG_LOCAL4")
     {
         _facility = LOG_LOCAL4;
     }
-    else if(facilityString == "LOG_LOCAL5")
+    else if (facilityString == "LOG_LOCAL5")
     {
         _facility = LOG_LOCAL5;
     }
-    else if(facilityString == "LOG_LOCAL6")
+    else if (facilityString == "LOG_LOCAL6")
     {
         _facility = LOG_LOCAL6;
     }
-    else if(facilityString == "LOG_LOCAL7")
+    else if (facilityString == "LOG_LOCAL7")
     {
         _facility = LOG_LOCAL7;
     }
     else
     {
-        throw InitializationException(__FILE__, __LINE__, "Invalid value for Ice.SyslogFacility: " + facilityString);
+        throw InitializationException(
+            __FILE__,
+            __LINE__,
+            "Invalid value for Ice.SyslogFacility: " + string{facilityString});
     }
 
     int logopt = LOG_PID | LOG_CONS;
     openlog(_prefix.c_str(), logopt, _facility);
 }
 
-Ice::SysLoggerI::SysLoggerI(const string& prefix, int facility) :
-    _facility(facility),
-    _prefix(prefix)
+Ice::SysLoggerI::SysLoggerI(string prefix, int facility) : _facility(facility), _prefix(std::move(prefix))
 {
     int logopt = LOG_PID | LOG_CONS;
     openlog(_prefix.c_str(), logopt, facility);
 }
 
-Ice::SysLoggerI::~SysLoggerI()
-{
-    closelog();
-}
+Ice::SysLoggerI::~SysLoggerI() { closelog(); }
 
 void
 Ice::SysLoggerI::print(const string& message)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     syslog(LOG_INFO, "%s", message.c_str());
 }
 
 void
 Ice::SysLoggerI::trace(const string& category, const string& message)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     string s = category + ": " + message;
     syslog(LOG_INFO, "%s", s.c_str());
 }
@@ -140,14 +134,14 @@ Ice::SysLoggerI::trace(const string& category, const string& message)
 void
 Ice::SysLoggerI::warning(const string& message)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     syslog(LOG_WARNING, "%s", message.c_str());
 }
 
 void
 Ice::SysLoggerI::error(const string& message)
 {
-    IceUtil::Mutex::Lock sync(*this);
+    lock_guard lock(_mutex);
     syslog(LOG_ERR, "%s", message.c_str());
 }
 
@@ -158,9 +152,9 @@ Ice::SysLoggerI::getPrefix()
 }
 
 Ice::LoggerPtr
-Ice::SysLoggerI::cloneWithPrefix(const string& prefix)
+Ice::SysLoggerI::cloneWithPrefix(string prefix)
 {
-    return ICE_MAKE_SHARED(SysLoggerI, prefix, _facility);
+    return make_shared<SysLoggerI>(std::move(prefix), _facility);
 }
 
 #endif

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

@@ -1,37 +1,34 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_SYS_LOGGER_I_H
 #define ICE_SYS_LOGGER_I_H
 
-#include <IceUtil/Mutex.h>
-#include <Ice/Logger.h>
+#include "Ice/Logger.h"
 
-namespace Ice
-{
+#include <mutex>
+#include <string_view>
 
-class SysLoggerI : public Logger, public ::IceUtil::Mutex
+namespace Ice
 {
-public:
-
-    SysLoggerI(const std::string&, const std::string&);
-    SysLoggerI(const std::string&, int);
-    ~SysLoggerI();
-
-    virtual void print(const std::string&);
-    virtual void trace(const std::string&, const std::string&);
-    virtual void warning(const std::string&);
-    virtual void error(const std::string&);
-    virtual std::string getPrefix();
-    virtual LoggerPtr cloneWithPrefix(const std::string&);
-
-private:
-
-    int _facility;
-    const std::string _prefix;
-};
-
+    class SysLoggerI final : public Logger
+    {
+    public:
+        SysLoggerI(std::string prefix, std::string_view facilityString);
+        SysLoggerI(std::string prefix, int facility);
+        ~SysLoggerI() override;
+
+        void print(const std::string&) final;
+        void trace(const std::string&, const std::string&) final;
+        void warning(const std::string&) final;
+        void error(const std::string&) final;
+        std::string getPrefix() final;
+        LoggerPtr cloneWithPrefix(std::string) final;
+
+    private:
+        int _facility;
+        const std::string _prefix;
+        std::mutex _mutex;
+    };
 }
 
 #endif

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

@@ -1,22 +1,17 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifdef ICE_USE_SYSTEMD
 
-#include <Ice/SystemdJournalI.h>
-#include <Ice/LocalException.h>
-#include <syslog.h>
-#include <systemd/sd-journal.h>
+#    include "SystemdJournalI.h"
+#    include "Ice/LocalExceptions.h"
+#    include <syslog.h>
+#    include <systemd/sd-journal.h>
 
 using namespace std;
 using namespace Ice;
 using namespace IceInternal;
 
-Ice::SystemdJournalI::SystemdJournalI(const string& prefix) :
-    _prefix(prefix)
-{
-}
+Ice::SystemdJournalI::SystemdJournalI(string prefix) : _prefix(std::move(prefix)) {}
 
 void
 Ice::SystemdJournalI::print(const string& message)
@@ -49,18 +44,22 @@ Ice::SystemdJournalI::getPrefix()
 }
 
 Ice::LoggerPtr
-Ice::SystemdJournalI::cloneWithPrefix(const string& prefix)
+Ice::SystemdJournalI::cloneWithPrefix(string prefix)
 {
-    return ICE_MAKE_SHARED(SystemdJournalI, prefix);
+    return make_shared<SystemdJournalI>(std::move(prefix));
 }
 
 void
 Ice::SystemdJournalI::write(int priority, const string& message) const
 {
-    sd_journal_send("MESSAGE=%s", message.c_str(),
-                    "PRIORITY=%i", priority,
-                    "SYSLOG_IDENTIFIER=%s", _prefix.c_str(),
-                    NULL); // Using NULL is necessary for EL7, see #293
+    sd_journal_send(
+        "MESSAGE=%s",
+        message.c_str(),
+        "PRIORITY=%i",
+        priority,
+        "SYSLOG_IDENTIFIER=%s",
+        _prefix.c_str(),
+        NULL); // Using NULL is necessary for EL7, see #293
 }
 
 #endif

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

@@ -1,37 +1,31 @@
-//
-// Copyright (c) ZeroC, Inc. All rights reserved.
-//
+// Copyright (c) ZeroC, Inc.
 
 #ifndef ICE_SYSTEMD_JOURNAL_I_H
 #define ICE_SYSTEMD_JOURNAL_I_H
 
 #ifdef ICE_USE_SYSTEMD
 
-#include <Ice/Logger.h>
+#    include "Ice/Logger.h"
 
 namespace Ice
 {
-
-class SystemdJournalI : public Logger
-{
-public:
-
-    SystemdJournalI(const std::string&);
-
-    virtual void print(const std::string&);
-    virtual void trace(const std::string&, const std::string&);
-    virtual void warning(const std::string&);
-    virtual void error(const std::string&);
-    virtual std::string getPrefix();
-    virtual LoggerPtr cloneWithPrefix(const std::string&);
-
-private:
-
-    void write(int, const std::string&) const;
-
-    const std::string _prefix;
-};
-
+    class SystemdJournalI final : public Logger
+    {
+    public:
+        SystemdJournalI(std::string);
+
+        void print(const std::string&) final;
+        void trace(const std::string&, const std::string&) final;
+        void warning(const std::string&) final;
+        void error(const std::string&) final;
+        std::string getPrefix() final;
+        LoggerPtr cloneWithPrefix(std::string) final;
+
+    private:
+        void write(int, const std::string&) const;
+
+        const std::string _prefix;
+    };
 }
 
 #endif

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

@@ -0,0 +1,96 @@
+// Copyright (c) ZeroC, Inc.
+
+#ifndef ICE_TARGET_COMPARE_H
+#define ICE_TARGET_COMPARE_H
+
+namespace Ice
+{
+    /// Compares the contents of two smart pointers.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if the contents are equal, `false` otherwise.
+    template<typename T, typename U> inline bool targetEqualTo(const T& lhs, const U& rhs)
+    {
+        if (lhs && rhs)
+        {
+            return *lhs == *rhs;
+        }
+        else
+        {
+            return !lhs && !rhs;
+        }
+    }
+
+    /// Compares the contents of two smart pointers.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if the left-hand side compares less than the right-hand side, `false` otherwise.
+    template<typename T, typename U> inline bool targetLess(const T& lhs, const U& rhs)
+    {
+        if (lhs && rhs)
+        {
+            return *lhs < *rhs;
+        }
+        else
+        {
+            return !lhs && rhs;
+        }
+    }
+
+    /// Compares the contents of two smart pointers.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if the left-hand side compares greater than the right-hand side, `false` otherwise.
+    template<typename T, typename U> inline bool targetGreater(const T& lhs, const U& rhs)
+    {
+        return targetLess(rhs, lhs);
+    }
+
+    /// Compares the contents of two smart pointers.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if the left-hand side compares less than or equal to the right-hand side, `false` otherwise.
+    template<typename T, typename U> inline bool targetLessEqual(const T& lhs, const U& rhs)
+    {
+        return !targetGreater(lhs, rhs);
+    }
+
+    /// Compares the contents of two smart pointers.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if the left-hand side compares greater than or equal to the right-hand side, `false` otherwise.
+    template<typename T, typename U> inline bool targetGreaterEqual(const T& lhs, const U& rhs)
+    {
+        return !targetLess(lhs, rhs);
+    }
+
+    /// Compares the contents of two smart pointers.
+    /// @param lhs The left-hand side.
+    /// @param rhs The right-hand side.
+    /// @return `true` if the contents are not equal, `false` otherwise.
+    template<typename T, typename U> inline bool targetNotEqualTo(const T& lhs, const U& rhs)
+    {
+        return !targetEqualTo(lhs, rhs);
+    }
+
+    /// Functor class that compares the contents of two smart pointers (or similar) of the given type using the given
+    /// comparator.
+    template<typename T, template<typename> class Compare> struct TargetCompare
+    {
+        /// Executes the functor to compare the contents of two smart pointers.
+        /// @return `true` if the contents satisfy the given comparator, `false` otherwise.
+        bool operator()(const T& lhs, const T& rhs) const
+        {
+            if (lhs && rhs)
+            {
+                return Compare<typename T::element_type>()(*lhs, *rhs);
+            }
+            else
+            {
+                return Compare<bool>()(static_cast<const bool>(lhs), static_cast<const bool>(rhs));
+            }
+        }
+    };
+}
+
+#endif