C>Несколько вопросов по поводу моей компетенции и читабельности кода который я пишу

#define LOG singleton<logger>::instance()

C>Несколько вопросов по поводу моей компетенции и читабельности кода который я пишу

enum LogType { Log }; // Это приём я называю глаголом.

template <class T>
logger & operator << (LogType,const T &x) { return singleton<logger>::instance() << x ; }

...

Log << "Log message" << endl ;

Ш>enum LogType { Log }; // Это приём я называю глаголом.

Ш>template <class T>
Ш>logger & operator << (LogType,const T &x) { return singleton<logger>::instance() << x ; }

Ш>...

Ш>Log << "Log message" << endl ;
Ш>

namespace log
{
    enum    message_type
    {
        mtError = -2,
        mtWarning = -1,
        mtDebug = 0
    };

    template< typename T >
    class MessageLogger
    {
    public:
        MessageLogger( T& log, int mt = mtWarning )
            :    mt_( mt ),
                log_( log )
        {};

        MessageLogger(const MessageLogger& ml )
            :    mt_( ml.mt_ ),
                log_( ml.log_ )
        {}

        virtual ~MessageLogger()
        {
            this->flush();
        };

        template<typename T>
            std::ostream& operator<<(const T& val)
        {
            collector_ << val;
            return collector_;
        }
    private:

        void flush( )
        {
            const char*    mtNames[] =
                {
                    "ERROR",
                    "Warning"
                };

            log_ << ( mt_ < 0 ? mtNames[ (mt_ +1 )* -1 ]  : "Debug" )
                << ": "
                << collector_.str()
                << std::endl;
        }
        
        int                            mt_;
        T&                                log_;
        std::ostringstream        collector_;
    };
};

template< typename OS >
inline log::MessageLogger<OS>
log_error( OS& os )
{
    return log::MessageLogger<OS>( os, log::mtError );
}

#define 
int main(int ac, char** av)
{
    log_error( std::cerr )
        << "It's show how MessageLogger may be used. "
        << 1234;
}

const &logger log(int priority = MESSAGE)
{
return singleton<logger>::instance()->getlog(priority);
}

class CLog
{
public:
         ........................................ 

        // заходим в критическую секцию класса, добавляем сообешние в очередь сообщений, возвращаем            // ссылку на лог для дальнейшей записи через <<
        CLog& Message(LogLevel level);

        // через этот оператор ведем запись любых типов данных. При необходимости можно указать                  // специализацию шаблона для конкретного типа
        template <class T>
        CLog& operator << (T message);

         ...........................................
};

template <>
CLog& CLog::operator << (endmsg manip)
{
        // этот оператор отвечает за запись сообщения, удаление сообщения из очереди, выход из критической         // секции. Таким образом, правильно обрабатываются "вложенные" сообщения.
}

CLog::Inst().Message(Notice) << "test" << endmsg();

C>Спасибо Я наверное примерно так видоизменю:

C>const &logger log(int priority = MESSAGE)
C>{
C>return singleton<logger>::instance()->getlog(priority);
C>}
C>

{
    template< typename T >
    class MessageLogger
    {
    public:
        MessageLogger( T& log, int mt = mtWarning )
            :    mt_( mt ),
                log_( log )
        {};

        MessageLogger(const MessageLogger& ml )
            :    mt_( ml.mt_ ),
                log_( ml.log_ )
        {}

        virtual ~MessageLogger()
        {
            log_.log_it( mt_, collector_.str() );
        };

        template<typename T>
        std::ostream& operator<<(const T& val)
        {
            collector_ << val;
            return collector_;
        }
    private:
        int                            mt_;
        T&                                log_;
        std::ostringstream        collector_;
    };

    struct Log
    {
        enum    message_type
        {
            mtError = -2,
            mtWarning = -1,
            mtDebug = 0
        };

        int        log_level;

        void log_it( int msgtype, const std::string& msg )
        {
            static const char*    mtNames[] =
                {
                    "ERROR",
                    "Warning"
                };

                /*
                    При необходимости вставляем тут синхронизацию
                */

            if( msgtype <= log_level )
            {
                /*
                    При необходимости добавляем вывод идинтификатора потока и т.п.
                */
                std::cout << ( msgtype < 0 ? mtNames[ (msgtype +1 )* -1 ]  : "Debug" )
                    << ": "
                    << msg
                    << std::endl;
            }
        }

        static Log& Instance()
        {
            static Log    Inst;
            return Inst;
        }
    };
};

inline log::MessageLogger<log::Log>
log_error()
{
    return log::MessageLogger<log::Log>( log::Log::Instance(), log::Log::mtError );
}

inline log::MessageLogger<log::Log>
log_debug( int iDebugLevel = 0)
{
    return log::MessageLogger<log::Log>( log::Log::Instance(), iDebugLevel );
}

int main(int ac, char** av)
{
    log_error( )
        << "It's show how MessageLogger may be used. "
        << 1234;

    log_debug(12) << "Debug with log level 0";
        
    log_debug() << "Debug with log level 0";

}