spdlog 输出自定义的对象的log

github.com/gabime/spdl…

#pragma once
//#include <boost/log/common.hpp>
//#include <boost/log/expressions.hpp>
//#include <boost/log/attributes.hpp>
//#include <boost/log/sources/logger.hpp>
//#include <boost/log/sinks/sync_frontend.hpp>
//#include <boost/log/sinks/text_file_backend.hpp>
#include "Singleton.h"
#include "DataModel.h"
#include "include/spdlog/spdlog.h"
//#include "include/spdlog/sinks/stdout_color_sinks.h"
#include "include/spdlog/sinks/rotating_file_sink.h"
#include "include/spdlog/fmt/ostr.h"  // support for user defined types
using namespace spdlog;
//namespace logging = boost::log;
//namespace attrs = boost::log::attributes;
//namespace src = boost::log::sources;
//namespace sinks = boost::log::sinks;
//namespace expr = boost::log::expressions;
//namespace keywords = boost::log::keywords;


//namespace MedibusServer
//{
//	// boost log file
//	src::logger logger;
//	// Create a text file sink
//	typedef sinks::synchronous_sink< sinks::text_file_backend > file_sink;
//	boost::shared_ptr< file_sink > sink(new file_sink(
//		keywords::file_name = "medibus.log",                       // file name pattern
//		keywords::target_file_name = "%Y%m%d_%H%M%S_%5N.log",   // file name pattern
//		keywords::rotation_size = 1638400                         // rotation size, in characters
//	));
//	void InitLogging()
//	{
//
//		// Set up where the rotated files will be stored
//		sink->locked_backend()->set_file_collector(sinks::file::make_collector(
//			keywords::target = "logs",                              // where to store rotated files
//			keywords::max_size = 100 * 1024 * 1024,                  // maximum total size of the stored files, in bytes
//			keywords::min_free_space = 100 * 1024 * 1024,           // minimum free space on the drive, in bytes
//			keywords::max_files = 512                               // maximum number of stored files
//		));
//
//		// Upon restart, scan the target directory for files matching the file_name pattern
//		sink->locked_backend()->scan_for_files();
//
//		sink->set_formatter
//		(
//			expr::format("%1%: [%2%] - %3%")
//			% expr::attr< unsigned int >("RecordID")
//			% expr::attr< boost::posix_time::ptime >("TimeStamp")
//			//% expr::attr< attrs::current_thread_id::value_type >("ThreadID")
//			% expr::smessage
//		);
//
//		// Add it to the core
//		logging::core::get()->add_sink(sink);
//
//		// Add some attributes too
//		logging::core::get()->add_global_attribute("TimeStamp", attrs::local_clock());
//		logging::core::get()->add_global_attribute("RecordID", attrs::counter< unsigned int >());
//		//logging::core::get()->add_global_attribute("ThreadID", attrs::current_thread_id());
//
//	}
//}


std::ostream& operator<<(std::ostream& os, const MedibusServer::EssentialInfo& info)
{
	return os << "info.MedibusCode:" << "<" << info.MedibusCode << ">"
	<< "info.CF10Code:" << "<" << info.CF10Code << ">"
	<< "info.CF10CodeDes:" << "<" << info.CF10CodeDes << ">"
	<< "info.facility:" << "<" << info.facility << ">"
	<< "info.bed:"  << "<" << info.bed << ">"
	<< "info.poc:" << "<" << info.poc << ">"
	<< std::endl;
}

template <> struct fmt::formatter<MedibusServer::EssentialInfo> : fmt::ostream_formatter {};


std::ostream& operator<<(std::ostream& os, const MedibusServer::AlarmInfo& info)
{
	return os << "MedibusCode: " << "<" << info.CommonInfo.MedibusCode << ">"
		<< "MedibusCodePage: " << "<" << info.CommonInfo.MedibusCodePage << ">"
		<< "CF10TypeCode: " << "<" << info.CommonInfo.CF10TypeCode << ">"
		<< "CF10TypeCodeDes: " << "<" << info.CommonInfo.CF10TypeCodeDes << ">"
		<< "VmdHandle: " << "<" << info.CommonInfo.VmdHandle << ">"
		<< "VmdCF10Code: " << "<" << info.CommonInfo.VmdCF10Code << ">"
		<< "VmdCF10CodeDes: " << "<" << info.CommonInfo.VmdCF10CodeDes << ">"
		<< "ChannelHandle: " << "<" << info.CommonInfo.ChannelHandle << ">"
		<< "ChannelCF10Code: " << "<" << info.CommonInfo.ChannelCF10Code << ">"
		<< "ChannelCF10CodeDes: " << "<" << info.CommonInfo.ChannelCF10CodeDes << ">"
		<< "MedicalClass: " << "<" << info.CommonInfo.MedicalClass << ">"
		<< "Context: " << "<" << info.CommonInfo.Context << ">"
		<< "Handle: " << "<" << info.CommonInfo.Handle << ">"
		<< "Source: " << "<" << info.Source << ">"
		<< "Kind: " << "<" << info.Kind << ">"
		<< "Priority: " << "<" << info.Priority << ">"
		<< "AlertType: " << "<" << info.AlertType << ">"
		<< "InitialActivationState: " << "<" << info.InitialActivationState << ">"
		<< "SystemAlarmHandle: " << "<" << info.SysAlarmInfo.Handle << ">"
		<< "SelfCheckPeriod: " << "<" << info.SysAlarmInfo.SelfCheckPeriod << ">"
		<< "MaxPhysiologicalParallelAlarms: " << "<" << info.SysAlarmInfo.MaxPhysiologicalParallelAlarms << ">"
		<< "MaxTechnicalParallelAlarms: " << "<" << info.SysAlarmInfo.MaxTechnicalParallelAlarms << ">"
		<< std::endl;
}

template <> struct fmt::formatter<MedibusServer::AlarmInfo> : fmt::ostream_formatter {};

std::ostream& operator<<(std::ostream& os, const MedibusServer::MetricInfo& info)
{
	return os << "MedibusCode: " << "<" << info.MedibusCode << ">"
		<< "MedibusCodePage: " << "<" << info.MedibusCodePage << ">"
		<< "CF10TypeCode: " << "<" << info.CF10TypeCode << ">"
		<< "CF10TypeCodeDes: " << "<" << info.CF10TypeCodeDes << ">"
		<< "UnitCode: " << "<" << info.UnitCode << ">"
		<< "VmdHandle: " << "<" << info.VmdHandle << ">"
		<< "VmdCF10Code: " << "<" << info.VmdCF10Code << ">"
		<< "VmdCF10CodeDes: " << "<" << info.VmdCF10CodeDes << ">"
		<< "ChannelHandle: " << "<" << info.ChannelHandle << ">"
		<< "ChannelCF10Code: " << "<" << info.ChannelCF10Code << ">"
		<< "ChannelCF10CodeDes: " << "<" << info.ChannelCF10CodeDes << ">"
		<< "MedicalClass: " << "<" << info.MedicalClass << ">"
		<< "Context: " << "<" << info.Context << ">"
		<< "Handle: " << "<" << info.Handle << ">"
		<< "CurAllowedValueCode: " << "<" << info.CurAllowedValueCode << ">"
		<< "CurAllowedValue: " << "<" << info.CurAllowedValue << ">"
		<< "Category: " << "<" << info.Category << ">"
		<< "Availability: " << "<" << info.Availability << ">"
		<< "Derivation: " << "<" << info.Derivation << ">"
		<< "Resolution: " << "<" << info.Resolution << ">"
		<< "DeterminationPeriod: " << "<" << info.DeterminationPeriod << ">"
		<< "MaxDelayTime: " << "<" << info.MaxDelayTime << ">"
		<< "LifeTimePeriod: " << "<" << info.LifeTimePeriod << ">"
		<< "SamplePeriod: " << "<" << info.SamplePeriod << ">"
		<< "LowRange: " << "<" << info.LowRange << ">"
		<< "UpperRange: " << "<" << info.UpperRange << ">"
		<< std::endl;
}

template <> struct fmt::formatter<MedibusServer::MetricInfo> : fmt::ostream_formatter {};


std::ostream& operator<<(std::ostream& os, const MedibusServer::DeviceInfo& info)
{
	return os << "DeviceName: " << "<" << info.DeviceName << ">"
		<< "DeviceId: " << "<" << info.DeviceId << ">"
		<< "CF10TypeCode: " << "<" << info.CF10TypeCode << ">"
		<< "CF10TypeCodeDes: " << "<" << info.CF10TypeCodeDes << ">"
		<< "Context: " << "<" << info.Context << ">"
		<< std::endl;
}

template <> struct fmt::formatter<MedibusServer::DeviceInfo> : fmt::ostream_formatter {};

namespace  MedibusServer
{

	enum level_enum : int {
		trace = SPDLOG_LEVEL_TRACE,
		debug = SPDLOG_LEVEL_DEBUG,
		info = SPDLOG_LEVEL_INFO,
		warn = SPDLOG_LEVEL_WARN,
		err = SPDLOG_LEVEL_ERROR,
		critical = SPDLOG_LEVEL_CRITICAL,
		off = SPDLOG_LEVEL_OFF,
		n_levels
	};

	class LogHelper : public Singleton<LogHelper>
	{
	public:
		friend class Singleton<LogHelper>;
		void Init()
		{
			m_LogFile = spdlog::rotating_logger_mt("rotatelog", "logs/medibus.log", 1048576 * 5, 3);
		}

		void LogFile(std::string msg, level_enum logLevel = level_enum::debug)
		{
			spdlog::set_level(static_cast<spdlog::level::level_enum>(logLevel));
			m_LogFile->debug(msg);
		}
		void LogFile(std::string msg, std::string instanceId, std::string sequenceId, std::string Info) {

			m_LogFile->debug("{} Instance Id is {}, Sequence Id is {}, string {}", msg, instanceId, sequenceId, Info);
		}
		void LogFile(std::string msg, std::string instanceId, std::string sequenceId, EssentialInfo Info) {

			m_LogFile->debug("{} Instance Id is {}, Sequence Id is {}, EssentialInfo {}", msg, instanceId, sequenceId, Info );
		}
		void LogFile(std::string msg, std::string instanceId, std::string sequenceId, MetricInfo Info) {

			m_LogFile->debug("{} Instance Id is {}, Sequence Id is {}, MetricInfo {}", msg, instanceId, sequenceId, Info);
		}
		void LogFile(std::string msg, std::string instanceId, std::string sequenceId, DeviceInfo Info) {

			m_LogFile->debug("{} Instance Id is {}, Sequence Id is {}, DeviceInfo {}", msg, instanceId, sequenceId, Info);
		}

		void LogFile(std::string msg, std::string instanceId, std::string sequenceId, AlarmInfo Info) {

			m_LogFile->debug("{} Instance Id is {}, Sequence Id is {}, AlarmInfo {}", msg, instanceId, sequenceId, Info);
		}
	private:
		LogHelper() = default;
		~LogHelper() = default;

		std::shared_ptr<spdlog::logger> m_LogFile;

	};
}