sag_plugin_logging.hpp

Go to the documentation of this file.

/*
 * Title:        plugin_logging.hpp
 * Description:  C++ API for logging from plugins
 * $Copyright (c) 2015-2017, 2019-2020, 2022 Software AG, Darmstadt, Germany and/or Software AG USA Inc., Reston, VA, USA, and/or its subsidiaries and/or its affiliates and/or their licensors.$
 * Use, reproduction, transfer, publication or disclosure is prohibited except as specifically provided for in your License Agreement with Software AG
 */

#ifndef _SAG_PLUGIN_LOGGING_HPP_
#define _SAG_PLUGIN_LOGGING_HPP_

#include <string>

namespace com {
namespace softwareag {
namespace _DATAT_INTERNAL_CPP_NAMESPACE { 

class CacheOwner
{
        friend class CacheForThisThread;
public:
        CacheOwner();
        ~CacheOwner();
private:
        void *cache;
        bool inuse;
};

class CacheForThisThread
{
public:
        CacheForThisThread(CacheOwner &owner);
        ~CacheForThisThread();
private:
        CacheOwner &owner;
};


class Logger
{
public:
        typedef sag_log_level_t level_t;
        
        Logger(const std::string &category): category(category), prefix(category), cachedLevel(getLevelImpl()) {}
        template<level_t LEVEL, typename... ARGS>
        void log(const char *format, ARGS... args) const;

        template<typename... ARGS>
        void log(level_t LEVEL, const char *format, ARGS... args) const;
        template<level_t LEVEL, typename... ARGS>
        void log(const std::string &format, ARGS... args) const;

        template<typename... ARGS>
        void log(level_t LEVEL, const std::string &format, ARGS... args) const;


        bool isEnabled(level_t LEVEL) const
        {
                return LEVEL <= getLevel();
        }

        level_t getLevel() const {
                return cachedLevel;
        }

        bool isCritEnabled() const { return isEnabled(SAG_LOG_CRIT); }
        bool isFatalEnabled() const { return isEnabled(SAG_LOG_FATAL); }
        bool isErrorEnabled() const { return isEnabled(SAG_LOG_ERROR); }
        bool isWarnEnabled() const { return isEnabled(SAG_LOG_WARN); }
        bool isInfoEnabled() const { return isEnabled(SAG_LOG_INFO); }
        bool isDebugEnabled() const { return isEnabled(SAG_LOG_DEBUG); }
        bool isTraceEnabled() const { return isEnabled(SAG_LOG_TRACE); }

        template<typename... ARGS> void crit(const char *format, ARGS... args) const { log<SAG_LOG_CRIT>(format, args...); }
        template<typename... ARGS> void fatal(const char *format, ARGS... args) const { log<SAG_LOG_FATAL>(format, args...); }
        template<typename... ARGS> void error(const char *format, ARGS... args) const { log<SAG_LOG_ERROR>(format, args...); }
        template<typename... ARGS> void warn(const char *format, ARGS... args) const { log<SAG_LOG_WARN>(format, args...); }
        template<typename... ARGS> void info(const char *format, ARGS... args) const { log<SAG_LOG_INFO>(format, args...); }
        template<typename... ARGS> void debug(const char *format, ARGS... args) const { log<SAG_LOG_DEBUG>(format, args...); }
        template<typename... ARGS> void trace(const char *format, ARGS... args) const { log<SAG_LOG_TRACE>(format, args...); }

        void crit(const char *str) const { log<SAG_LOG_CRIT>("%s", str); }
        void fatal(const char *str) const { log<SAG_LOG_FATAL>("%s", str); }
        void error(const char *str) const { log<SAG_LOG_ERROR>("%s", str); }
        void warn(const char *str) const { log<SAG_LOG_WARN>("%s", str); }
        void info(const char *str) const { log<SAG_LOG_INFO>("%s", str); }
        void debug(const char *str) const { log<SAG_LOG_DEBUG>("%s", str); }
        void trace(const char *str) const { log<SAG_LOG_TRACE>("%s", str); }


        void crit(const std::string &str) const { log<SAG_LOG_CRIT>("%s", str.c_str()); }
        void fatal(const std::string &str) const { log<SAG_LOG_FATAL>("%s", str.c_str()); }
        void error(const std::string &str) const { log<SAG_LOG_ERROR>("%s", str.c_str()); }
        void warn(const std::string &str) const { log<SAG_LOG_WARN>("%s", str.c_str()); }
        void info(const std::string &str) const { log<SAG_LOG_INFO>("%s", str.c_str()); }
        void debug(const std::string &str) const { log<SAG_LOG_DEBUG>("%s", str.c_str()); }
        void trace(const std::string &str) const { log<SAG_LOG_TRACE>("%s", str.c_str()); }

        template<typename... ARGS> void crit(const std::string &format, ARGS... args) const { log<SAG_LOG_CRIT>(format, args...); }
        template<typename... ARGS> void fatal(const std::string &format, ARGS... args) const { log<SAG_LOG_FATAL>(format, args...); }
        template<typename... ARGS> void error(const std::string &format, ARGS... args) const { log<SAG_LOG_ERROR>(format, args...); }
        template<typename... ARGS> void warn(const std::string &format, ARGS... args) const { log<SAG_LOG_WARN>(format, args...); }
        template<typename... ARGS> void info(const std::string &format, ARGS... args) const { log<SAG_LOG_INFO>(format, args...); }
        template<typename... ARGS> void debug(const std::string &format, ARGS... args) const { log<SAG_LOG_DEBUG>(format, args...); }
        template<typename... ARGS> void trace(const std::string &format, ARGS... args) const { log<SAG_LOG_TRACE>(format, args...); }
        const std::string &getPrefix() const { return prefix; }

private:
        level_t getLevelImpl() const;
        std::string category;
        std::string prefix;
        level_t cachedLevel;
};

}

namespace connectivity { using namespace _DATAT_INTERNAL_CPP_NAMESPACE; }

}} // com.softwareag.connectivity

// internal implementation included from these files
#include <sag_internal/logging.hpp>

#endif // _SAG_PLUGIN_LOGGING_HPP_