f1x1t/myxlib
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Удалена библиотека журналирования

Browse Source
This commit is contained in:
Andrei Astafev
2020-01-27 18:02:12 +03:00
parent 305421c491
commit d1613d814f
15 changed files with 1 additions and 657 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/myx/filesystem/CMakeLists.txt
View File

@ -27,8 +27,6 @@ add_pvs_check(${current_target})
add_format_sources(${current_target} ${current_target_sources} ${current_target_headers})
target_include_directories(${current_target} SYSTEM PUBLIC ${Qt5Core_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${FMT_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${SPDLOG_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/src)
target_include_directories(${current_target} PRIVATE ${CMAKE_BINARY_DIR}/include)

47
src/myx/log/CMakeLists.txt
View File

@ -1,47 +0,0 @@
# Название основной цели и имя библиотеки в текущем каталоге
set(current_target log)
# Список файлов исходных текстов
set(current_target_sources
${CMAKE_CURRENT_SOURCE_DIR}/spdlog.cpp
${CMAKE_CURRENT_SOURCE_DIR}/spdlog_qt.cpp
)
# Список заголовочных файлов (используется для установки)
set(current_target_headers
${CMAKE_CURRENT_SOURCE_DIR}/spdlog.hpp
${CMAKE_CURRENT_SOURCE_DIR}/spdlog_qt.hpp
)
add_common_library(TARGET ${current_target} OUTPUT_NAME myx-${current_target}
SOURCES ${current_target_sources})
common_target_properties(${current_target})
add_clang_tidy_check(${current_target} ${current_target_sources})
add_clang_analyze_check(${current_target} ${current_target_sources})
add_clazy_check(${current_target} ${current_target_sources})
add_pvs_check(${current_target})
# Форматирование исходников
add_format_sources(${current_target} ${current_target_sources} ${current_target_headers})
target_include_directories(${current_target} SYSTEM PUBLIC ${Qt5Core_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${FMT_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${SPDLOG_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/src)
# Цель, используемая только для установки заголовочных файлов без компиляции проекта
add_custom_target(${current_target}-install-headers
COMMAND "${CMAKE_COMMAND}"
-DCMAKE_INSTALL_COMPONENT=headers -P "${CMAKE_BINARY_DIR}/cmake_install.cmake"
)
# Правила для установки
install(TARGETS ${current_target}_static ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR})
if(BUILD_SHARED_LIBS)
install(TARGETS ${current_target}_shared LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR})
endif()
install(FILES ${current_target_headers}
COMPONENT headers
DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/${PROJECT_NAME}/${current_target})
install(FILES ${CMAKE_BINARY_DIR}/${current_target}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig)

259
src/myx/log/spdlog.cpp
View File

@ -1,259 +0,0 @@
#include "spdlog.hpp"
#include <myx/base/config.hpp>
namespace myx {
namespace log {
Logger default_logger( "default" );
Logger::Logger( std::string name ) :
m_logger ( nullptr ),
m_name ( std::move( name ) ),
m_outputPattern ( "[%H:%M:%S %z] [%n] [%^---%L---%$] %v" ),
m_baseFileName ( "default" ),
m_maxRotatingFileSize ( rotatingFileSize ),
m_maxRotatingFilesCount( 3 ),
m_outputLevel ( spdlog::level::trace ),
m_flushLevel ( spdlog::level::warn ),
m_nullSink ( nullptr ),
m_stdoutSink ( nullptr ),
m_stderrSink ( nullptr ),
m_syslogSink ( nullptr ),
m_basicFileSink ( nullptr ),
m_rotatingFileSink ( nullptr ),
m_dailyFileSink ( nullptr )
{
m_logger = std::make_shared< spdlog::logger >( m_name, nullptr );
m_logger->sinks().clear();
m_logger->flush_on( m_flushLevel );
m_logger->set_level( m_outputLevel );
m_logger->set_pattern( m_outputPattern );
}
spdlog::level::level_enum Logger::outputLevel() const
{
return( m_outputLevel );
}
void Logger::setOutputLevel( const spdlog::level::level_enum outputLevel )
{
m_outputLevel = outputLevel;
}
spdlog::level::level_enum Logger::flushLevel() const
{
return( m_flushLevel );
}
void Logger::setFlushLevel( const spdlog::level::level_enum flushLevel )
{
m_flushLevel = flushLevel;
}
std::string Logger::outputPattern() const
{
return( m_outputPattern );
}
void Logger::setOutputPattern( const std::string& outputPattern )
{
m_outputPattern = outputPattern;
}
std::shared_ptr< spdlog::logger > Logger::logger()
{
return( m_logger );
}
std::string Logger::name() const
{
return( m_name );
}
void Logger::setName( const std::string& name )
{
m_name = name;
}
std::string Logger::baseFileName() const
{
return( m_baseFileName );
}
void Logger::setBaseFileName( const std::string& baseFileName )
{
m_baseFileName = baseFileName;
}
void Logger::enableNullSink()
{
if ( m_nullSink == nullptr )
{
m_nullSink = std::make_shared< spdlog::sinks::null_sink_st >();
m_logger->sinks().push_back( m_nullSink );
}
}
void Logger::disableNullSink()
{
if ( m_nullSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_nullSink ), sinks.end() );
m_nullSink.reset();
m_nullSink = nullptr;
}
}
void Logger::enableStdoutSink()
{
if ( m_stdoutSink == nullptr )
{
m_stdoutSink = std::make_shared< spdlog::sinks::ansicolor_stdout_sink_st >();
m_logger->sinks().push_back( m_stdoutSink );
}
}
void Logger::disableStdoutSink()
{
if ( m_stdoutSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_stdoutSink ), sinks.end() );
m_stdoutSink.reset();
m_stdoutSink = nullptr;
}
}
void Logger::enableStderrSink()
{
if ( m_stderrSink == nullptr )
{
m_stderrSink = std::make_shared< spdlog::sinks::ansicolor_stderr_sink_st >();
m_logger->sinks().push_back( m_stderrSink );
}
}
void Logger::disableStderrSink()
{
if ( m_stderrSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_stderrSink ), sinks.end() );
m_stderrSink.reset();
m_stderrSink = nullptr;
}
}
void Logger::enableSyslogSink()
{
if ( m_syslogSink == nullptr )
{
m_syslogSink = std::make_shared< spdlog::sinks::syslog_sink_st >();
m_logger->sinks().push_back( m_syslogSink );
}
}
void Logger::disableSyslogSink()
{
if ( m_syslogSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_syslogSink ), sinks.end() );
m_syslogSink.reset();
m_syslogSink = nullptr;
}
}
void Logger::enableBasicFileSink()
{
if ( m_basicFileSink == nullptr )
{
m_basicFileSink = std::make_shared< spdlog::sinks::basic_file_sink_st >( m_baseFileName );
m_logger->sinks().push_back( m_basicFileSink );
}
}
void Logger::disableBasicFileSink()
{
if ( m_basicFileSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_basicFileSink ), sinks.end() );
m_basicFileSink.reset();
m_basicFileSink = nullptr;
}
}
void Logger::enableRotatingFileSink()
{
if ( m_rotatingFileSink == nullptr )
{
m_rotatingFileSink = std::make_shared< spdlog::sinks::rotating_file_sink_st >( m_baseFileName, m_maxRotatingFileSize, m_maxRotatingFilesCount );
m_logger->sinks().push_back( m_rotatingFileSink );
}
}
void Logger::disableRotatingFileSink()
{
if ( m_rotatingFileSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_rotatingFileSink ), sinks.end() );
m_rotatingFileSink.reset();
m_rotatingFileSink = nullptr;
}
}
void Logger::enableDailyFileSink()
{
if ( m_dailyFileSink == nullptr )
{
const int rotationHour = 23;
const int rotationMinute = 59;
m_dailyFileSink = std::make_shared< spdlog::sinks::daily_file_sink_st >( m_baseFileName, rotationHour, rotationMinute );
m_logger->sinks().push_back( m_dailyFileSink );
}
}
void Logger::disableDailyFileSink()
{
if ( m_dailyFileSink != nullptr )
{
auto sinks = m_logger->sinks();
sinks.erase( std::remove( sinks.begin(), sinks.end(), m_dailyFileSink ), sinks.end() );
m_dailyFileSink.reset();
m_dailyFileSink = nullptr;
}
}
} // namespace log
} // namespace myx

122
src/myx/log/spdlog.hpp
View File

@ -1,122 +0,0 @@
#ifndef MYX_LOG_SPDLOG_HPP_
#define MYX_LOG_SPDLOG_HPP_
#include <spdlog/sinks/sink.h>
#include <spdlog/sinks/null_sink.h>
#include <spdlog/sinks/syslog_sink.h>
#include <spdlog/sinks/basic_file_sink.h>
#include <spdlog/sinks/rotating_file_sink.h>
#include <spdlog/sinks/daily_file_sink.h>
namespace myx {
namespace log {
const size_t rotatingFileSize = 256 * 1024;
class Logger
{
std::shared_ptr< spdlog::logger > m_logger;
std::string m_name;
std::string m_outputPattern;
std::string m_baseFileName;
std::size_t m_maxRotatingFileSize;
std::size_t m_maxRotatingFilesCount;
spdlog::level::level_enum m_outputLevel;
spdlog::level::level_enum m_flushLevel;
std::shared_ptr< spdlog::sinks::null_sink_st > m_nullSink;
std::shared_ptr< spdlog::sinks::ansicolor_stdout_sink_st > m_stdoutSink;
std::shared_ptr< spdlog::sinks::ansicolor_stderr_sink_st > m_stderrSink;
std::shared_ptr< spdlog::sinks::syslog_sink_st > m_syslogSink;
std::shared_ptr< spdlog::sinks::basic_file_sink_st > m_basicFileSink;
std::shared_ptr< spdlog::sinks::rotating_file_sink_st > m_rotatingFileSink;
std::shared_ptr< spdlog::sinks::daily_file_sink_st > m_dailyFileSink;
public:
Logger( std::string name );
void init();
std::shared_ptr< spdlog::logger > logger();
std::string name() const;
void setName( const std::string& name );
std::string baseFileName() const;
void setBaseFileName( const std::string& baseFileName );
void enableNullSink();
void disableNullSink();
void enableStdoutSink();
void disableStdoutSink();
void enableStderrSink();
void disableStderrSink();
void enableSyslogSink();
void disableSyslogSink();
void enableBasicFileSink();
void disableBasicFileSink();
void enableRotatingFileSink();
void disableRotatingFileSink();
void enableDailyFileSink();
void disableDailyFileSink();
spdlog::level::level_enum outputLevel() const;
void setOutputLevel( const spdlog::level::level_enum outputLevel );
spdlog::level::level_enum flushLevel() const;
void setFlushLevel( const spdlog::level::level_enum flushLevel );
std::string outputPattern() const;
void setOutputPattern( const std::string& outputPattern );
}; // class Logger
extern Logger default_logger;
template < class F, class ... Args >
void trace( F&& format, Args&& ... args ) noexcept
{
default_logger.logger()->trace( std::forward< F >( format ),
std::forward< Args >( args )... );
}
template < class F, class ... Args >
void debug( F&& format, Args&& ... args ) noexcept
{
default_logger.logger()->debug( std::forward< F >( format ),
std::forward< Args >( args )... );
}
template < class F, class ... Args >
void info( F&& format, Args&& ... args ) noexcept
{
default_logger.logger()->info( std::forward< F >( format ),
std::forward< Args >( args )... );
}
template < class F, class ... Args >
void warn( F&& format, Args&& ... args ) noexcept
{
default_logger.logger()->warn( std::forward< F >( format ),
std::forward< Args >( args )... );
}
template < class F, class ... Args >
void error( F&& format, Args&& ... args ) noexcept
{
default_logger.logger()->error( std::forward< F >( format ),
std::forward< Args >( args )... );
}
template < class F, class ... Args >
void log( spdlog::level::level_enum lv, F&& format, Args&& ... args ) noexcept
{
default_logger.logger()->log( lv, std::forward< F >( format ),
std::forward< Args >( args )... );
}
} // namespace log
} // namespace myx
#endif // ifndef MYX_LOG_SPDLOG_HPP_

44
src/myx/log/spdlog_qt.cpp
View File

@ -1,44 +0,0 @@
#include "spdlog.hpp"
#include "spdlog_qt.hpp"
#include <QCoreApplication>
namespace myx {
namespace log {
void spdlog_qt_message_handler( QtMsgType type, const QMessageLogContext& context, const QString& qMsg )
{
Q_UNUSED( context )
if ( !default_logger.logger() )
{
return;
}
auto message = qMsg.toUtf8();
switch ( type )
{
case QtDebugMsg:
default_logger.logger()->debug( message.constData() );
break;
case QtInfoMsg:
default_logger.logger()->info( message.constData() );
break;
case QtWarningMsg:
default_logger.logger()->warn( message.constData() );
break;
case QtCriticalMsg:
default_logger.logger()->critical( message.constData() );
break;
case QtFatalMsg:
default_logger.logger()->critical( "FATAL: %s", message.constData() );
QCoreApplication::exit( 1 );
break;
}
} // messageHandler
} // namespace log
} // namespace myx

18
src/myx/log/spdlog_qt.hpp
View File

@ -1,18 +0,0 @@
#ifndef MYX_LOG_SPDLOG_QT_HPP_
#define MYX_LOG_SPDLOG_QT_HPP_
#include <QMessageLogContext>
#include <QString>
#include <QDebug>
namespace myx {
namespace log {
void spdlog_qt_message_handler( QtMsgType type, const QMessageLogContext& context, const QString& qMsg );
} // namespace log
} // namespace myx
#endif // ifndef MYX_LOG_SPDLOG_QT_HPP_

2
src/myx/math/CMakeLists.txt
View File

@ -37,8 +37,6 @@ add_pvs_check(${current_target})
add_format_sources(${current_target} ${current_target_sources} ${current_target_headers})
target_include_directories(${current_target} SYSTEM PUBLIC ${Qt5Core_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${FMT_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${SPDLOG_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/src)
target_include_directories(${current_target} PRIVATE ${CMAKE_BINARY_DIR}/include)

2
src/myx/qt/CMakeLists.txt
View File

@ -21,8 +21,6 @@ add_pvs_check(${current_target})
add_format_sources(${current_target} ${current_target_sources} ${current_target_headers})
target_include_directories(${current_target} SYSTEM PUBLIC ${Qt5Core_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${FMT_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PUBLIC ${SPDLOG_INCLUDE_DIRS})
target_include_directories(${current_target} SYSTEM PRIVATE ${CMAKE_SOURCE_DIR}/src)
# Цель, используемая только для установки заголовочных файлов без компиляции