一个简单的logsystem

最新推荐文章于 2021-12-02 20:10:36 发布

最新推荐文章于 2021-12-02 20:10:36 发布 · 146 阅读

文章标签：

博客展示了一个Java日志流类的实现代码，包含初始化、打开关闭文件流、设置状态、输出数据等操作，还定义了日志模式和日志级别控制，可用于日志记录和调试信息输出。










 std{

     < Type, _Traits>  basic_logstream
    {

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


         logmode
        {
           log_common = ,
           log_html   = ,
        };


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

        
         open( * _filename, append = ,logmode lmode= log_common)
        {
            m_filestream.open(_filename,ios_base::out);
        }

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

         fail()
        {

             m_filestream.fail();
        }

         is_open()
        {
             m_filestream.is_open();
        }

         bad()
        {
             m_filestream.bad();
        }

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

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

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

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

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

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

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

          !()
        {
               !m_filestream;
        }
         * ()
        {
             (*)m_filestream;
        }
         opfx()
        {
             m_filestream.opfx();
        }
         osfx()
        {
            m_filestream.osfx();
        }
        streamsize precision()
        {
             m_filestream.precision();
        }
        streamsize precision(streamsize _NewPrecision)
        {
              m_filestream.precision(_NewPrecision);
        }

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

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

        
         < DataType>_Myos& <<(DataType data)
        {
               (m_curLevel >= m_forbiddenLevel)
               {
                   m_filestream<<data;
               }
                *;
        }

        
        _Myos& <<(_MyBasOs& (__cdecl *_Pfn)(_MyBasOs&))
        {       
            ((*_Pfn)(m_filestream));
             *;
        }

        _Myos& <<(_MyBaseios& (__cdecl *_Pfn)(_MyBaseios&))
        {       
            (*_Pfn)(m_filestream);
             (*);
        }

        _Myos& <<(ios_base& (__cdecl *_Pfn)(ios_base&))
        {       
            (*_Pfn)(*(ios_base *));
             (*);
        }


         set_forbidden_level( level)
        {
            m_forbiddenLevel = level;
        }

         set_level( level)
        {
            m_curLevel = level;
        }



        


         trace( * fmt, ...)
        {

            (m_curLevel >= m_forbiddenLevel)
            {
                buffer[];
                args;
               va_start(args, fmt);
               _vsnprintf(buffer, , fmt, args);
               va_end(args);
               buffer[] = ;


                OutputDebugStringA(buffer);

                cout<<buffer;
                m_filestream<<buffer;
            }
        }
         trace( level,  * fmt, ...)
        {

            (level >= m_forbiddenLevel)
            {
             buffer[];
                args;
               va_start(args, fmt);
               _vsnprintf(buffer, , fmt, args);
               va_end(args);
               buffer[] = ;

                OutputDebugStringA(buffer);

                cout<<buffer;
                m_filestream<<buffer;
            }
        }
    :
        _MyFileStrem       m_filestream;

                        m_curLevel;
                        m_forbiddenLevel;

    };

     basic_logstream<    , char_traits<>    > logstream;
     basic_logstream< , char_traits<> > wlogstream;

}