一个简单的logsystem

这是一个简单的Logsystem,主要目的是提供一个简单的实现方式,以后复杂的应用可以在这个基础上改进,
接口上基本上把fstream包了一层,而且也在std namespace里.本来是本来是从basic_ofstrem继承的，
后来想想那样有些东西难处理(主要是要对输出做限制)

该log可以对输出级别进行限制,只对在允许范围内的输出信息被输出,否则不输出>
以后准备做成可以输出HTML格式的。加一些便利函数,输出日期啊等.

#ifndef __LOGSYTEM_H__
#define __LOGSYTEM_H__
/*
stanlylee's log system
module name : logstream
*/
#ifdef _WIN32
#include <Windows.h>
#endif
#include <fstream>
namespace std{

    template <typename Type,typename _Traits> class basic_logstream
    {

        void init()
        {
            m_curLevel = 1;
            m_forbiddenLevel = 1;
        }
    public:
        typedef  basic_ofstream<Type,_Traits>     _MyFileStrem;
        typedef  basic_ios<Type, _Traits>        _MyBaseios;
        typedef  basic_logstream<Type,_Traits>    _Myos;
        typedef  basic_ostream<Type,_Traits>      _MyBasOs;


        enum logmode
        {
           log_common = 0x00000000,
           log_html   = 0x00000001,
        };


        basic_logstream()
        {
                init();
        }
        basic_logstream(const char* _filename,bool append = false,logmode lmode= log_common)
        {
            init();
            m_filestream.open(_filename,append,lmode);
        }

        //basic operation like fstream;
        void open(const char* _filename,bool append = false,logmode lmode= log_common)
        {
            m_filestream.open(_filename,ios_base::out);
        }

        void close()
        {
            m_filestream.close();
            return;
        }

        bool fail()
        {

            return m_filestream.fail();
        }

        bool is_open()
        {
            return m_filestream.is_open();
        }

        bool bad()
        {
            return m_filestream.bad();
        }

        void setstate(ios_base::iostate _state,bool _Expcept = false)
        {
            m_filestream.setstate(_state,_Expcept);
        }
        void setstate(ios_base::io_state _state)
        {
            m_filestream.setstate(_state);
        }
        void clear(ios_base::iostate _state = ios_base::goodbit,bool _Expcept = false)
        {
            m_filestream.clear(_state,_Expcept);
        }

        void clear(ios_base::io_state _state)
        {
            m_filestream.clear(_state);
        }

        Type fill(Type _Newfill)
        {
            return m_filestream.fill(_Newfill);
        }

        Type fill()
        {
            return m_filestream.fill();
        }

        ios::fmtflags flags()
        {
            return  m_filestream.flags();
        }

        ios::fmtflags flags(ios::fmtflags _Newflags)
        {
            m_filestream.flush();
            return  m_filestream.flags(_Newflags);
        }

        _Myos& flush()
        {
            m_filestream.flush();
            return *this;
        }

        bool operator !()
        {
              return !m_filestream;
        }
        operator void* ()
        {
            return (void*)m_filestream;
        }
        bool opfx()
        {
            return m_filestream.opfx();
        }
        void osfx()
        {
            m_filestream.osfx();
        }
        streamsize precision()
        {
            return m_filestream.precision();
        }
        streamsize precision(streamsize _NewPrecision)
        {
             return m_filestream.precision(_NewPrecision);
        }

        streamsize width()
        {
            return m_filestream.width();
        }

        streamsize width(streamsize _NewPrecision)
        {
            return m_filestream.width(_NewPrecision);
        }

        //operator <<
        template <typename DataType>_Myos& operator<<(DataType data)
        {
               if(m_curLevel >= m_forbiddenLevel)
               {
                   m_filestream<<data;
               }
               return *this;
        }

        //manipulators
        _Myos& operator<<(_MyBasOs& (__cdecl *_Pfn)(_MyBasOs&))
        {       // call basic_ostream manipulator
            ((*_Pfn)(m_filestream));
            return *this;
        }

        _Myos& operator<<(_MyBaseios& (__cdecl *_Pfn)(_MyBaseios&))
        {       // call basic_ios manipulator
            (*_Pfn)(m_filestream);
            return (*this);
        }

        _Myos& operator<<(ios_base& (__cdecl *_Pfn)(ios_base&))
        {       // call ios_base manipulator
            (*_Pfn)(*(ios_base *)this);
            return (*this);
        }


        void set_forbidden_level(int level)
        {
            m_forbiddenLevel = level;
        }

        void set_level(int level)
        {
            m_curLevel = level;
        }



        /**
        Here is the format;
        */
        void trace(const char* fmt, ...)
        {
             
            if(m_curLevel >= m_forbiddenLevel)
            {
               char buffer[512];
               va_list args;
               va_start(args, fmt);
               _vsnprintf(buffer, 1024, fmt, args);
               va_end(args);
               buffer[511] = '/0';

#ifdef _WIN32
                OutputDebugStringA(buffer);
#endif
                cout<<buffer;
                m_filestream<<buffer;
            }
        }
        void trace(int level, const char* fmt, ...)
        {
            if(level >= m_forbiddenLevel)
            {
               char buffer[512];
               va_list args;
               va_start(args, fmt);
               _vsnprintf(buffer, 1024, fmt, args);
               va_end(args);
               buffer[511] = '/0';
#ifdef _WIN32
                OutputDebugStringA(buffer);
#endif
                cout<<buffer;
                m_filestream<<buffer;
            }
        }
    private:
        _MyFileStrem       m_filestream;

        int                m_curLevel;
        int                m_forbiddenLevel;

    };

    typedef basic_logstream<char    , char_traits<char>    > logstream;
    typedef basic_logstream<wchar_t , char_traits<wchar_t> > wlogstream;

}
#endif