1.日志系统

#ifndef __SYLAR_LOG_H__
#define __SYLAR_LOG_H__

#include<iostream>
#include<string>
#include<stdint.h>//为了使用int32_t
#include<memory>//为了使用shared_ptr
#include<list>
#include<vector>
#include<sstream>
#include<fstream>//为了使用std::ofstream  m_filestream;


namespace sylar//为了区分和别人的代码里有重名的一些内容
{
//每个日志在生成出来的时候，把它定义成LogEvent，这样的话，把它里面所要用的属性、字段等，都放里面。
//日志事件
class LogEvent
{
public:
	//使用了C++11中的智能指针,方便内存管理
	typedef std::shared_ptr<LogEvent> ptr;
	LogEvent();
private:
	const char *m_file = nullptr;//文件名 //nullptr：C++11内容
	int32_t m_line = 0;			 //行号
	uint32_t m_elapse = 0;		 //程序启动开始到现在的毫秒数		
	int m_threadId = 0;			 //线程号
	uint32_t m_fiberId = 0;		 //协程号 //因为是协程库，所以还要有一个协程
	uint64_t m_time;			 //时间戳
	std::string m_content;		 //消息内容
};

//日志级别
class LogLevel
{
public:
	//定义日志级别
	//弹幕：日志级别完全可以用策略模式？为了以后的多种功能
	enum Level
	{
		DEBUG = 1,
		INFO = 2,
		WARN = 3,
		ERROR = 4,
		FATAL = 5
	};
};

//日志格式器
//目前只有一种Formatter，那么先只有一个Formatter
class LogFormatter
{
public:
	typedef std::shared_ptr<LogFormatter> ptr;

	//当pattern赋值的狮虎，我们会根据pattern的格式来解析出它里面的item的信息
	LogFormatter(const std::string& pattern);

	//格式示例：%t	%thread_id	%m%n
	std::string format(LogEvent::ptr event);//把formatter的一个string提供给Appender输出
	
	//创建一个日志解析的子模块，定义成一个FormatItem的抽象类，再定义它的子类用来实现
private:
	class FormatItem
	{
	public:
		typedef std::shared_ptr<FormatItem> ptr;
		virtual ~FormatItem(){}
		//使用ostream作为输出，不再使用std::string 来作为返回值，因为它会多个组合起来
		//这样性能会更好一点
		virtual void format(std::ostream os,LogEvent::ptr event) = 0;
	};

	void init();//init方法来做pattern的解析
	//定义很多种具体的子类，每个子类负责输出一部分
private:
	std::string m_pattern;//输出formatter结构
	std::vector<FormatItem> m_items;

private:

};


//日志输出的地址
//可以输出到控制台、文件、网络等...
//这里实现文控制台(STD)、文件的....
//先定义一个基类，里面只有一个纯虚函数log，这样它的子类就必须实现这个方法
class LogAppender
{
public:
	typedef std::shared_ptr<LogAppender> ptr;
	//因为日志输出地址有很多，所以把它定义成一个虚类
	//定义一个虚析构函数，让子类在继承的时候继承它，
	//如果不写成虚析构函数，那么它的子类在释放的时候，可能会产生释放的问题
	virtual ~LogAppender(){};
	virtual void log(LogLevel::Level level, LogEvent::ptr event) = 0;

	//设置formatter的方法
	void setFormatter(LogFormatter::ptr val){ m_formatter = val; }
	//获取formatter的方法
	LogFormatter::ptr getFormatter()const{ return m_formatter; }
protected://由于是虚拟的基类，有可能要用到它的level，所以基类中的属性应该是个protected，这样的话，子类就可以使用到
	LogLevel::Level m_level;//主要针对哪些日志来定义的级别
	//Appender里面还有一个Formatter对象，这个formatter是定义要输出的格式
	//可能有的输出格式要把线程、文件都输出出来，而有的不需要输出这些
	//以及时间格式是如何定义的都可能不一样
	//所以在这里定义一个LogFormatter
	LogFormatter::ptr m_formatter;
};

//日志（输出）器
//只有满足了日志级别的日志才会被输出
class Logger
{
public:
	typedef std::shared_ptr<Logger> ptr;//

	//弹幕：成员函数能够直接初始化是C++11开始就支持的特性，
	Logger(const std::string &name = "root");
	void log(LogLevel::Level level, LogEvent::ptr event);

	//定义五种级别的日志
	void debug(LogEvent::ptr event);
	void info(LogEvent::ptr event);
	void warn(LogEvent::ptr event);
	void error(LogEvent::ptr event);
	void fatal(LogEvent::ptr event);

	//添加和删除日志级别
	void addAppender(LogAppender::ptr appender);	//添加Appender
	void delAppender(LogAppender::ptr appender);	//删除Appender
	LogLevel::Level getLevel()const{ return m_level;} //获取日志级别
	void setLevel(LogLevel::Level val){ m_level = val; }//设置日志级别
private:
	std::string m_name;								//日志名称
	LogLevel::Level m_level;						//日志级别，只有满足了日志级别的日志才会被输出
	std::list<LogAppender::ptr> m_appenders;		//Appender是输出到目的地的集合，这里用一个链来实现表
};

//输出到控制台（Std）的Appender
class StdoutLogAppender : public LogAppender
{
public:
	//1.先定义出智能指针，后面很多时候，都是用智能指针来操作的
	typedef std::shared_ptr<StdoutLogAppender> ptr;
	//2.实现基类的抽象函数log
	//从父类继承的函数的实现，可以用override来描述
	void log(LogLevel::Level level, LogEvent::ptr event) override;
private:

};

//定义输出到文件的Appender
class FileLogAppender : public LogAppender
{
	//1.先定义智能指针
	typedef std::shared_ptr<FileLogAppender> ptr;
	//2.实现基类的抽象函数log
	//从父类继承的函数的实现，可以用override来描述
	FileLogAppender(const std::string& filename);//FileLog跟StdLog不一样，因为它要输出到文件里，因此它需要一个文件名
	void log(LogLevel::Level level, LogEvent::ptr event) override;

	//重新打开文件，重新打开成功返回true
	bool reopen();
private:
	std::string m_filename;
	std::ofstream  m_filestream;//用流的方式去输出
};

}

#endif //__SYLAR_LOG_H__


、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、
#include"Log.h"

namespace sylar
{
Logger::Logger(const std::string &name = "root") : m_name(name)
{

}


void Logger::addAppender(LogAppender::ptr appender)	//添加Appender
{
	m_appenders.push_back(appender);//这里先不考虑线程安全，等后面线程库做出来之后再考虑
}

void Logger::delAppender(LogAppender::ptr appender)	//删除Appender
{
	//利用遍历的方式删除日志输出地址
	for (auto it = m_appenders.begin();//auto 是C++11 的内容
		it != m_appenders.end();++it)
	{
		if (*it == appender)
		{
			m_appenders.erase(it);
			break;
		}
	}
}



void Logger::log(LogLevel::Level level, LogEvent::ptr & event)
{
	if (level >= m_level)//就开始输出
	{
		//输出就是要输出到每个appender里去
		//因此，就遍历每个appenders，然后再用appender把它输出出来
		for (auto & i : m_appenders)
		{
			i->log(level, event);
		}
	}
	else
	{

	}
}

//定义五种级别的日志
//下面的这几个方法，都是利用上面的Logger::log方法来实现的，只是为了便捷
//就像有的人喜欢用相应日志级别的函数输出，而不喜欢加 LogLevel
void Logger::debug(LogEvent::ptr event)
{
	debug(LogLevel::DEBUG, event);
}
void Logger::info(LogEvent::ptr event)
{
	debug(LogLevel::INFO event);
}
void Logger::warn(LogEvent::ptr event)
{
	debug(LogLevel::WARN, event);
}
void Logger::error(LogEvent::ptr event)
{
	debug(LogLevel::ERROR, event);
}
void fatal(LogEvent::ptr event)
{
	debug(LogLevel::FATAL, event);
}

FileLogAppender::FileLogAppender(const std::string& filename)
	:m_filename(filename)
{

}

void FileLogAppender::log(LogLevel::Level level, LogEvent::ptr event)
{
	if (level >= m_level)
	{
		m_filestream << m_formatter.format(event);//把文件按照我们需要的方式输出出来
	}
}

bool FileLogAppender::reopen()
{
	if (m_filestream)//如果为true，就说明是已经打开的状态
	{
		m_filestream.close();//先关闭
	}
	m_filestream.open(m_filename);//再打开
	return !!m_filestream;
}

void StdoutLogAppender::log(LogLevel::Level level, LogEvent::ptr event)
{
	
	if (level >= m_level)
	{
		//初始化完成后，一定会有一个formatter
		//使用formatter把日志序列化
		if (level >= m_level)
		{
			std::cout << m_formatter.format(event);
		}
	}
}

LogFormatter::LogFormatter(const std::string &pattern)
	:m_pattern(pattern)
{

}

std::string LogFormatter::format(LogEvent::ptr event)
{
	std::stringstream ss;
	for (auto& i :m_items)
	{
		i->format(ss, event);
	}
	return ss.str();
}


//两种格式：
//1.%xxx
//2.%xxx{xxx}
//3. %%
void LogFormatter::init()
{
	std::vector<std::pair<std::string, int>> vec;
	size_t last_pos = 0;
	for (size_t i = 0; i < m_pattern.size();++i)
	{
		if (m_pattern[i] == '%')
		{
			if ((i + 1) < m_pattern.size())
			{

			}
		}
	}
}



}