logging.h

Go to the documentation of this file.

/*
*
* templog library
*
* Copyright Hendrik Schober
* Distributed under the Boost Software License, Version 1.0.
*    (See accompanying file LICENSE_1_0.txt or copy at
*     http://www.boost.org/LICENSE_1_0.txt)
*
* see http://templog.sourceforge.net/ for more info
*
*/

#if !defined(TEMPLOG_LOGGING_H)
#define TEMPLOG_LOGGING_H

/**********************************************************************************************/
#include "config.h"

/**********************************************************************************************/
#include <typeinfo>
#include <iostream>
#include <string>
#include <sstream>
#include <vector>

/**********************************************************************************************/
#include "type_lists.h"
#include "tuples.h"

/**********************************************************************************************/

namespace templog {

    /******************************************************************************************/
    /* source information */

#   define TEMPLOG_SOURCE                                __FILE__, __LINE__                                             
#   define TEMPLOG_SOURCE_SIGN                           const char* const file_, const unsigned long line_             
#   define TEMPLOG_SOURCE_SIGN_IGNORE                    const char* const , const unsigned long                        
#   define TEMPLOG_SOURCE_PASS                           file_, line_                                                   
#   define TEMPLOG_SOURCE_INIT                           file_data_(file_), line_data_(line_)                           
#   define TEMPLOG_SOURCE_ASSIGN(Obj_)                   file_data_=Obj_.file_data_; line_data_=Obj_.line_data_         

#   define TEMPLOG_SOURCE_FILE                           file_                                                          
#   define TEMPLOG_SOURCE_LINE                           line_                                                          

#   define TEMPLOG_SOURCE_DATA                           const char* const file_data_; const unsigned long line_data_   
#   define TEMPLOG_SOURCE_DATA_PASS                      file_data_, line_data_                                         
#   define TEMPLOG_SOURCE_DATA_FILE                      file_data_                                                     
#   define TEMPLOG_SOURCE_DATA_LINE                      line_data_                                                     

#   define TEMPLOG_SOURCE_ACCESS(Obj_)                   Obj_.file_data_, Obj_.line_data_                               
#   define TEMPLOG_SOURCE_ACCESS_FILE(Obj_)              Obj_.file_data_                                                
#   define TEMPLOG_SOURCE_ACCESS_LINE(Obj_)              Obj_.line_data_                                                

    /******************************************************************************************/
    /* severities and audiences */

    enum severity { sev_debug   = 1 
                  , sev_info        
                  , sev_message     
                  , sev_warning     
                  , sev_error       
                  , sev_fatal       
                  };

    enum audience { aud_developer = 1 
                  , aud_support       
                  , aud_user          
                  };

    template< int Aud1_, int Aud2_ = 0, int Aud3_ = 0 >
    struct audience_list : public templ_meta::int_type_list_generator< 0
                                                                       , Aud1_
                                                                       , Aud2_
                                                                       , Aud3_
                                                                       >::result_type
    {
        typedef typename templ_meta::int_type_list_generator< 0
                                                            , Aud1_
                                                            , Aud2_
                                                            , Aud3_
                                                            >::result_type
                                                        result_type;
    };

    const char* get_name(severity sev);

    const char* get_short_name(severity sev);

    const char* get_name(audience aud);

    const char* get_short_name(audience aud);

    /******************************************************************************************/
    /* log intermediate */

    template< int Sev_, int Aud_, bool Forward_, class Params_ >
    struct log_intermediate {
        typedef Params_                                 parameters_type;

        parameters_type                     parameters;

        log_intermediate( const parameters_type& p = parameters_type() )
            : parameters(p) {}

    };

    template< int Sev_, int Aud_, class ParamList_, typename Param_ >
    inline
    log_intermediate< Sev_, Aud_, false, templ_meta::nil >
    operator<<( const log_intermediate<Sev_,Aud_,false,ParamList_>&, const Param_& )
    {
        typedef log_intermediate< Sev_, Aud_
                                , false
                                , templ_meta::nil >     log_intermediate_t;
        return log_intermediate_t();
    }

    template< int Sev_, int Aud_, class ParamList_, typename Param_ >
    inline
    log_intermediate< Sev_, Aud_, true, templ_meta::tuple<const Param_*,ParamList_> >
    operator<<( const log_intermediate<Sev_,Aud_,true,ParamList_>& lim, const Param_& p )
    {
        typedef log_intermediate< Sev_, Aud_
                                , true
                                , templ_meta::tuple<const Param_*,ParamList_> >
                                                        log_intermediate_t;
        return log_intermediate_t( templ_meta::tuple<const Param_*,ParamList_>(&p,lim.parameters) );
    }

    /******************************************************************************************/
    /* log forwarder */

    template< class Logger_ >
    struct log_forwarder {
        TEMPLOG_SOURCE_DATA;

        log_forwarder(TEMPLOG_SOURCE_SIGN)
            : TEMPLOG_SOURCE_INIT {}

        template< int Sev_, int Aud_, bool Forward_, class Params_ >
        void operator=(const log_intermediate<Sev_,Aud_,Forward_,Params_>& li)
        { Logger_::fwd(TEMPLOG_SOURCE_DATA_PASS,li); }

        log_forwarder& operator=(const log_forwarder& rhs)
        { TEMPLOG_SOURCE_ASSIGN(rhs); return *this; }

    };

    /******************************************************************************************/
    /* logger */

    template< class Logger_
            , int MinSeverity_
            , class AudienceList_ >
    class logger;

    template< class Logger_
            , int MinSeverity_
            , int Aud1_, int Aud2_, int Aud3_ >
    class logger< Logger_, MinSeverity_, audience_list<Aud1_,Aud2_,Aud3_> > {
    private:
        typedef typename audience_list<Aud1_,Aud2_,Aud3_>::result_type
                                                        audience_list_type;
        template< int S_, int A_ >
        struct evaluate_params {
            enum { sev = ( MinSeverity_ <= S_ )
                 , aud = templ_meta::int_type_list_includes<audience_list_type,A_>::result
                 , result = (sev && aud) };
        };
    public:
        typedef logger< Logger_, MinSeverity_, audience_list<Aud1_,Aud2_,Aud3_> >
                                                        logger_type;
        typedef Logger_                                 forward_logger_type;

        static
        log_forwarder<logger_type>
        get_forwarder(TEMPLOG_SOURCE_SIGN)
        { return log_forwarder<logger_type>(TEMPLOG_SOURCE_PASS); }

        template< int Sev_, int Aud_ >
        static 
        log_intermediate<Sev_,Aud_,evaluate_params<Sev_,Aud_>::result,templ_meta::nil>
        get_intermediate()
        { return log_intermediate< Sev_, Aud_, evaluate_params<Sev_,Aud_>::result, templ_meta::nil >(); }

        template< int Sev_, int Aud_, class Params_ >
        static void fwd( TEMPLOG_SOURCE_SIGN_IGNORE, const log_intermediate< Sev_, Aud_, false, Params_ >& )
        {}

        template< int Sev_, int Aud_, class Params_ >
        static void fwd( TEMPLOG_SOURCE_SIGN       , const log_intermediate< Sev_, Aud_, true , Params_ >& lim )
        { forward_logger_type::fwd(TEMPLOG_SOURCE_PASS,lim); }
    };

    /******************************************************************************************/
    /* formatting policies */

    template< typename FormattingPolicy_ >
    class formating_policy_base {
    public:
        template< class WritePolicy_, int Sev_, int Aud_, class ParamList_ >
        static void write_msg(TEMPLOG_SOURCE_SIGN, const ParamList_& parameters)
        {
            typedef typename WritePolicy_::incremental_write_support
                                                          incremental_write_support;
            do_write<WritePolicy_,Sev_,Aud_>(TEMPLOG_SOURCE_PASS, parameters, incremental_write_support());
        }

    protected:
        template< class WritePolicy_, class WriteToken_, typename T >
        static void write_obj(WriteToken_& token, const T& obj)
        { do_write_obj<WritePolicy_>(token,obj); }

        template< class WritePolicy_, class WriteToken_, class Param_, class ParamList_ >
        static void write_params( WriteToken_& token 
                                , const templ_meta::tuple<const Param_*,ParamList_>& parameters )
        { do_write_params_<WritePolicy_>(token,parameters); }

    private:
        template< class WritePolicy_, int Sev_, int Aud_, class ParamList_ >
        static void do_write(TEMPLOG_SOURCE_SIGN, const ParamList_& parameters, templ_meta::boolean<true>)
        {
            templ_meta::nil dummy;
            WritePolicy_::begin_write();
            FormattingPolicy_::template write<WritePolicy_,Sev_,Aud_>(dummy,TEMPLOG_SOURCE_PASS,parameters);
            do_write_endl<WritePolicy_>(dummy,typename WritePolicy_::needs_endl());
            WritePolicy_::end_write();
        }

        template< class WritePolicy_, int Sev_, int Aud_, class ParamList_ >
        static void do_write(TEMPLOG_SOURCE_SIGN, const ParamList_& parameters, templ_meta::boolean<false>)
        {
            std::ostringstream oss;
            FormattingPolicy_::template write<WritePolicy_,Sev_,Aud_>(oss,TEMPLOG_SOURCE_PASS,parameters);
            do_write_endl<WritePolicy_>(oss,typename WritePolicy_::needs_endl());
            WritePolicy_::write_str(oss.str());
        }

        template< class WritePolicy_, typename T >
        static void do_write_obj(templ_meta::nil&, const T& obj)
        { WritePolicy_::write_obj(obj); }

        template< class WritePolicy_, typename T >
        static void do_write_obj(std::ostream& os, const T& obj)
        { os << obj; }

        template< class WritePolicy_, class WriteToken_, class Param_, class ParamList_ >
        static void do_write_params_( WriteToken_& token 
                                    , const templ_meta::tuple<const Param_*,ParamList_>& parameters )
        {
            do_write_params_<WritePolicy_>(token,parameters.tail);
            do_write_params_<WritePolicy_>(token,parameters.head);
        }

        template< class WritePolicy_, class WriteToken_, class Param_ >
        static void do_write_params_( WriteToken_& token 
                                    , const Param_* pparameter )
        { write_obj<WritePolicy_>(token,*pparameter); }

        template< class WritePolicy_, class WriteToken_ >
        static void do_write_params_( WriteToken_& 
                                    , templ_meta::nil  )
        {}

        template< class WritePolicy_, class WriteToken_ >
        static void do_write_endl( WriteToken_& token 
                                 , templ_meta::boolean<true> )
        { write_obj<WritePolicy_>(token,'\n'); }

        template< class WritePolicy_, class WriteToken_ >
        static void do_write_endl( WriteToken_& token 
                                 , templ_meta::boolean<false> )
        {}
    };

    class sev_aud_formating_policy : public formating_policy_base<sev_aud_formating_policy> {
    public:
        template< class WritePolicy_, int Sev_, int Aud_, class WriteToken_, class ParamList_ >
        static void write(WriteToken_& token, TEMPLOG_SOURCE_SIGN_IGNORE, const ParamList_& parameters)
        {
            write_obj<WritePolicy_>( token, '<' );
            write_obj<WritePolicy_>( token, get_short_name(static_cast<severity>(Sev_)) );
            write_obj<WritePolicy_>( token, '|' );
            write_obj<WritePolicy_>( token, get_short_name(static_cast<audience>(Aud_)) );
            write_obj<WritePolicy_>( token, ">: " );
            write_params<WritePolicy_>(token, parameters);
        }
    };

    template< class FwdFormattingPolicy_ >
    class visual_studio_formating_policy : public formating_policy_base< visual_studio_formating_policy<FwdFormattingPolicy_> > {
    public:
        template< class WritePolicy_, int Sev_, int Aud_, class WriteToken_, class ParamList_ >
        static void write(WriteToken_& token, TEMPLOG_SOURCE_SIGN, const ParamList_& parameters)
        {
            typedef formating_policy_base< visual_studio_formating_policy<FwdFormattingPolicy_> > base;
            base::template write_obj<WritePolicy_>( token, TEMPLOG_SOURCE_FILE );
            base::template write_obj<WritePolicy_>( token, '(' );
            base::template write_obj<WritePolicy_>( token, TEMPLOG_SOURCE_LINE );
            base::template write_obj<WritePolicy_>( token, ") : " );
            FwdFormattingPolicy_::template write<WritePolicy_,Sev_,Aud_>( token, TEMPLOG_SOURCE_PASS, parameters );
        }
    };

    /******************************************************************************************/
    /* writing policies */

    template< class WritePolicy_, bool Endl_, bool Incremental_ >
    class write_policy_base {
    public:
        typedef templ_meta::boolean<Incremental_>         incremental_write_support;
        typedef templ_meta::boolean<Endl_>                needs_endl;

        template< class FormattingPolicy_, int Sev_, int Aud_, class ParamList_ >
        static void write_msg(TEMPLOG_SOURCE_SIGN, const ParamList_& parameters)
        { FormattingPolicy_::template write_msg<WritePolicy_,Sev_,Aud_>(TEMPLOG_SOURCE_PASS, parameters); }
    };

    template< class WritePolicy_, bool Endl_ >
    class incremental_write_policy_base : public write_policy_base<WritePolicy_,Endl_,true > {};

    template< class WritePolicy_, bool Endl_ >
    class non_incremental_write_policy_base : public write_policy_base<WritePolicy_,Endl_,false> {};

    class stderr_write_policy : public incremental_write_policy_base<stderr_write_policy,true> {
    public:
        template< int Sev_, int Aud_ >
        struct writes { enum { result = true }; };

        static bool is_writing(int /*sev*/, int /*aud*/){return true;}

        static void begin_write()                       {}

        template< typename T >
        static void write_obj(const T& obj)             {std::cerr << obj;}

        static void end_write()                         {}

    };

#   if defined(_WIN32)
        class windbg_write_policy : public non_incremental_write_policy_base<windbg_write_policy,true> {
        public:
            template< int Sev_, int Aud_ >
            struct writes { enum { result = true }; };

            static bool is_writing(int /*sev*/, int /*aud*/){return true;}

            static void write_str(const std::string& str);
        };
#   endif //defined(_WIN32)

    class dynamic_write_policy : public non_incremental_write_policy_base<dynamic_write_policy,true> {
    public:
        class writer_base {
        public:
            virtual bool is_writing(int, int) const        {return true;}
            virtual void write_str(const std::string& str) const = 0;
            //virtual ~writer_base() {} // virtual dtor not needed, no dynamic instances
        };

        template< class WritePolicy_ >
        class writer : public writer_base {
        public:
            virtual void write_str(const std::string& str) const
            { do_write_str(str,typename WritePolicy_::incremental_write_support()); }
        private:
            static void do_write_str(const std::string& str, templ_meta::boolean<true > )
            { WritePolicy_::write_obj(str); }
            static void do_write_str(const std::string& str, templ_meta::boolean<false> )
            { WritePolicy_::write_str(str); }
        };

        template< int Sev_, int Aud_ >
        struct writes { enum { result = true }; };

        static bool is_writing(int sev, int aud)
        { const writer_base* ptr=get(); return ptr ? ptr->is_writing(sev,aud) : false; }

        static void write_str(const std::string& str)
        { const writer_base* ptr=get(); if(ptr) ptr->write_str(str);  }

        static const writer_base* set_writer(const writer_base* pw)
        { std::swap(pw,get()); return pw; }

        template< class WritePolicy_ >
        class auto_writer : public writer<WritePolicy_> {
        public:
            auto_writer()                                 {set_writer(this);}
            ~auto_writer()                                {set_writer(NULL);}
        };

    private:
        static const writer_base*& get()
        { static const writer_base* ptr_=NULL; return ptr_; }
    };

    /******************************************************************************************/
    /* default formatting and write policies*/

#   if defined(_WIN32)
        typedef visual_studio_formating_policy<sev_aud_formating_policy>  std_formating_policy;
        typedef windbg_write_policy                                       std_write_policy;
#   else //defined(_WIN32)
        typedef sev_aud_formating_policy                                  std_formating_policy;
        typedef stderr_write_policy                                       std_write_policy;
#   endif //defined(_WIN32)

    /******************************************************************************************/
    /* global logger */

    template< class FormattingPolicy_, class WritePolicy_ >
    class non_filtering_logger {
    public:
        template< int Sev_, int Aud_, class Params_ >
        static void fwd( TEMPLOG_SOURCE_SIGN, const log_intermediate< Sev_, Aud_, false , Params_ >& )
        {}

        template< int Sev_, int Aud_, class Params_ >
        static void fwd( TEMPLOG_SOURCE_SIGN, const log_intermediate< Sev_, Aud_, true , Params_ >& lim )
        { WritePolicy_::template write_msg<FormattingPolicy_,Sev_,Aud_>(TEMPLOG_SOURCE_PASS, lim.parameters); }
    };

    typedef non_filtering_logger< std_formating_policy
                                , std_write_policy>   global_logger;

    /******************************************************************************************/

}

using templog::sev_debug;
using templog::sev_info;
using templog::sev_message;
using templog::sev_warning;
using templog::sev_error;
using templog::sev_fatal;

using templog::aud_developer;
using templog::aud_support;
using templog::aud_user;

#define TEMPLOG_LOG(TLogger_,Sev_,Aud_) TLogger_::get_forwarder(TEMPLOG_SOURCE) = \
                                        TLogger_::template get_intermediate<Sev_,Aud_>()

/**********************************************************************************************/

#endif //defined(TEMPLOG_LOGGING_H)

/**********************************************************************************************/
/* EOF */

---