logger.h

#pragma once
 
#include <string>
#include <functional>
#include <limits>
#include <mutex>
 
#include "hazelcast/util/export.h"
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(push)
#pragma warning(disable : 4251) // for dll export
#endif
 
#ifndef HZ_LOGGING_DISABLED
#define HZ_LOG(lg, lvl, msg)                                                   \
    if ((lg).enabled(::hazelcast::logger::level::lvl)) {                       \
        (lg).log(::hazelcast::logger::level::lvl, (msg));                      \
    }
#else
#define HZ_LOG(lg, lvl, msg)
#endif
 
namespace hazelcast {
 
class HAZELCAST_API logger
{
public:
    enum class level;
 
    using handler_type = std::function<
      void(const std::string&, const std::string&, level, const std::string&)>;
 
    logger(std::string instance_name,
           std::string cluster_name,
           level lvl,
           handler_type handler);
 
    bool enabled(level lvl) noexcept;
 
    void log(level lvl, const std::string& msg) noexcept;
 
    static void default_handler(const std::string& instance_name,
                                const std::string& cluster_name,
                                level lvl,
                                const std::string& msg) noexcept;
 
private:
    const std::string instance_name_;
    const std::string cluster_name_;
    const level level_;
    const handler_type handler_;
    static std::mutex cout_lock_;
};
 
enum class logger::level : int
{
    all = (std::numeric_limits<int>::min)(),
    finest = 300,
    finer = 400,
    fine = 500,
    info = 800,
    warning = 900,
    severe = 1000,
    off = (std::numeric_limits<int>::max)()
};
 
HAZELCAST_API std::ostream&
operator<<(std::ostream&, logger::level level);
 
} // namespace hazelcast
 
#if defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64)
#pragma warning(pop)
#endif