Logger.hpp

 
#ifndef RTI_CDS_LOGGER_HPP_
#define RTI_CDS_LOGGER_HPP_
 
#include <dds/core/Reference.hpp>
#include <rti/config/Logger.hpp>
 
#include "clouddiscoveryservice/clouddiscoveryservice_service.h"
#include "clouddiscoveryservice/clouddiscoveryservice_log.h"
 
namespace rti { namespace cds {
 
class Logger
{
public:
 
    typedef rti::config::Verbosity Verbosity;
    typedef rti::config::LogCategory LogCategory;
    typedef rti::config::PrintFormat PrintFormat;
 
    static Logger& instance()
    {
        static Logger singleton;
        return singleton;
    }
 
    void service_verbosity(rti::config::Verbosity verbosity)
    {
        NDDS_Config_Logger_set_verbosity_by_service(
                NDDS_Config_Logger_get_instance(),
                NDDS_CONFIG_LOG_SERVICE_CLOUD_DISCOVERY,
                static_cast<NDDS_Config_LogVerbosity>(verbosity.underlying()));
    }
 
     rti::config::Verbosity service_verbosity()
    {
        RTILogBitmap instrumentation_mask =
                NDDS_Config_Logger_get_verbosity_by_service(
                        NDDS_Config_Logger_get_instance(),
                        NDDS_CONFIG_LOG_SERVICE_CLOUD_DISCOVERY);
 
        return static_cast<rti::config::Verbosity::type>(instrumentation_mask);
    }
 
    void error(const std::string& msg)
    {
        this->error(msg.c_str());
    }
 
    void error(const char *msg)
    {
        this->message(rti::config::LogLevel::EXCEPTION, msg);
    }
 
    void warn(const std::string& msg)
    {
        this->warn(msg.c_str());
    }
 
    void warn(const char *msg)
    {
        this->message(rti::config::LogLevel::WARNING, msg);
    }
 
    void local(const std::string& msg)
    {
        this->local(msg.c_str());
    }
 
    void local(const char *msg)
    {
        this->message(rti::config::LogLevel::STATUS_LOCAL, msg);
    }
 
    void remote(const std::string& msg)
    {
        this->remote(msg.c_str());
    }
 
    void remote(const char *msg)
    {
        this->message(rti::config::LogLevel::STATUS_REMOTE, msg);
    }
 
    void debug(const std::string& msg)
    {
        this->debug(msg.c_str());
    }
 
    void debug(const char *msg)
    {
        this->message(rti::config::LogLevel::STATUS_ALL, msg);
    }
 
    virtual ~Logger()
    {
    }
 
private:
 
    void message(const rti::config::LogLevel& level, const char* msg)
    {
        RTI_CDS_Logger_log(
                static_cast<NDDS_Config_LogLevel>(level.underlying()),
                "%s",
                msg);
    }
 
    Logger()
    {
    }
 
    // Disable copy
    Logger(const Logger&);
    Logger& operator=(const Logger&);
};
 
}}
 
#endif // RTI_CDS_LOGGER_HPP_