/home/mhx/git/github/libmoost/include/moost/logging/global.hpp

Go to the documentation of this file.

/* vim:set ts=3 sw=3 sts=3 et: */
#ifndef MOOST_LOGGING_GLOBAL_HPP__
#define MOOST_LOGGING_GLOBAL_HPP__

#include <iostream>
#include <boost/filesystem.hpp>

#include <log4cxx/logger.h>
#include <log4cxx/basicconfigurator.h>
#include <log4cxx/logmanager.h>
#include <log4cxx/propertyconfigurator.h>

#include "../utils/singleton.hpp"
#include "pseudo_ostream.hpp"
#include "../compiler/attributes.hpp"

#define MLOG_INIT() \
   moost::logging::global_singleton::instance().enable(std::string(*argv))

#define MLOG_IS_INITIALISED() \
   moost::logging::global_singleton::instance().is_configured() && \
   moost::logging::global_singleton::instance().is_enabled()

namespace moost { namespace logging {

   class global
   {
   template <typename T> friend
      class moost::utils::singleton_default<T>::friend_type;

   private:
      global()
         : enabled_(false)
      {
         // Initially, logging shall be disabled
         disable();
      }

   public:

      bool is_enabled() const
      {
         return enabled_;
      }

      bool is_configured() const
      {
         return log4cxx::LogManager::getLoggerRepository()->isConfigured();
      }

      bool enable()
      {
         out_
            << "Enable logging using default basic config"
            << std::endl;

         log4cxx::BasicConfigurator::configure();
         log4cxx::Logger::getRootLogger()->setLevel(log4cxx::Level::getDebug());
         return set_enabled(is_configured());
      }

      bool enable(boost::filesystem::path const & filepath,
            bool use_default = false)
      {
         out_
            << "Enable logging using "
            << filepath
            << std::endl;

         log4cxx::LogManager::shutdown();

         if(boost::filesystem::exists(filepath))
         {
            log4cxx::PropertyConfigurator::configure(filepath.string());
         }
         else
         if(use_default)
         {
            return enable();
         }

         return set_enabled(is_configured());
      }

      bool enable(std::string const & filepath,
            bool use_default = false)
      {
         // whether name is a filename or a path this returns the leaf
         std::string s = boost::filesystem::path(filepath).leaf();

         s.append(".lcf");
         char const * search_path[] = {
            //-------------------------------------------------
            // you get these paths for free when building debug
#ifndef NDEBUG
            "./",
            "./etc/",
            "./etc/mir/",
            "~/",
            "~/.mir/",
#endif
            //-------------------------------------------------
            "/etc/",
            "/etc/mir/",
         };

         size_t const search_path_len =
            sizeof(search_path)/sizeof(search_path[0]);
         std::string cfgfile;
         bool found = false;

         out_
            << "Searching for logging config file..."
            << std::endl;

         for(size_t i = 0; i < search_path_len && !found; i++)
         {
            cfgfile = (boost::filesystem::path(search_path[i]) /= s).string();

            out_
               << "-  trying: "
               << cfgfile
               << std::endl;

            found = boost::filesystem::exists(cfgfile);
         }

         out_
            << "Logging config "
            << (found?"":"not ")
            << "found"
            << std::endl;

         if(found)
         {
            return enable(boost::filesystem::path(cfgfile), use_default);
         }

         return enable();
      }

      void disable()
      {
         log4cxx::LogManager::getLoggerRepository()->setConfigured(true);
         log4cxx::Logger::getRootLogger()->setLevel(log4cxx::Level::getOff());
         enabled_ = false;

         out_
            << "All logging has been disabled"
            << std::endl;
      }

      void attach_ostream(std::ostream & out)
      {
         out_.attach(out);
      }

      void detach_ostream()
      {
         out_.detach();
      }

      pseudo_ostream & get_ostream()
      {
         return out_;
      }

   private:
      bool set_enabled(bool enabled)
      {
         enabled_ = enabled;

          out_
             << "logging was "
             << (enabled_?"":"not ")
             << "successfully enabled"
             << std::endl;

          return enabled_;
      }


   private:
      bool enabled_;
      pseudo_ostream out_;
   };

   typedef moost::utils::singleton_default<global> global_singleton;

   constructor__(init_global_singleton)
   {
      global_singleton::instance().disable();
   }
}}

#endif