Log库：
类关系
首先有3个大类：LogEvent、LogAppender、Logger、LogFormat；
关系如下：
Logger：具体log的实现
LogAppender：将Log信息传输到不同的目的地，根据不同的需求派生出不同的类
LogFormat：存储格式信息，并根据LogEvent生成信息
log Event：存储具体的log信息，如内容、时间戳、线程号等等
类实现：
LogFormat：格式由%[ item ]{ [data] }构成
首先对于每一个item，我的方法是通过策略模式来解决，每一个item都继承自FormatItem，比如输出时间信息的TimeFormatItem，输出线程号的ThreadIDFormatItem，每一种不同的信息都用不同的策略；
然后将格式字符串解析出来，根据不同的格式生成不同的策略，最后在接收LogEvent的时候从中提取信息到每一个Item中，并生成最后的Log信息
class FormatItem {
public:
using Ptr = std::shared_ptr<FormatItem>;
virtual ~FormatItem(){}
//os存储最后的字符串
virtual void format(std::ostream& os, Logger*, LogLevel, LogEvent::Ptr) = 0;
};比如%d %m解析为输出时间和内容；
LogEvent
LogEvent就是一个存储信息的地方，在这一方面没什么好说的，一堆变量，我们可以让LogEvent支持c风格的printf，这样我们可以将处理后的字符串作为内容：
class LogEvent {
public:
//"xxxx %s" ,"string" 的形式会在void Format(const char* fmt, va_list al, bool isStart = false);进行，因为va_list是char*，
//所以设计一个Flag标记，防止错误载入
struct Flag{};
using Ptr = std::shared_ptr<LogEvent>;
LogEvent(std::shared_ptr<Logger> logger, LogLevel level
, const char* file, int32_t m_line, uint32_t elapse
, uint32_t thread_id, uint32_t fiber_id, uint64_t time);
const std::string GetContent() { return m_Content.str(); }
std::stringstream& GetStream() { return m_Content; }
uint32_t GetElapse() { return m_elaspe; }
uint64_t GetTime() { return m_time; }
uint32_t GetThreadID() { return m_ThreadId; }
uint32_t GetLine() { return m_Line; }
uint32_t GetFiberID() { return m_FiberId; }
const char* GetFile() { return m_file; }
LogLevel GetLevel() { return m_Level; }
std::shared_ptr<Logger>& GetLogger() { return m_Logger; }
void Format(const char* fmt, ...);
private:
void Format(const char* fmt, Flag ,va_list al, bool isStart = false);
const char* m_file = nullptr; //文件名
std::stringstream m_Content; //内容
int32_t m_Line = 0; //行号
uint32_t m_ThreadId = 0; //线程号
uint32_t m_FiberId = 0; //协程号
uint64_t m_time = 0; //时间戳
uint32_t m_elaspe = 0; //从重新开始到目前的时间
std::shared_ptr<Logger> m_Logger;
LogLevel m_Level;
friend class LogFormatter;
};支持c风格的格式化：
void LogEvent::Format(const char* fmt, ...) {
va_list al;
va_start(al, fmt);
Format(fmt, Flag{},al, true);
va_end(al);
}
void LogEvent::Format(const char* fmt, Flag ,va_list al,bool isStart) {
char* buf = nullptr;
int len = vasprintf(&buf, fmt, al);
if (len != -1) {
m_Content << buf;
free(buf);
}
}注意，如果是Windows的话vasprint要自己去实现一下：
#ifdef _WIN32
int vasprintf(char** strp, const char* fmt, va_list ap){
va_list ap_copy;
va_copy(ap_copy, ap);
int len = vsnprintf(NULL, 0, fmt, ap);
if (len < 0) {
return -1;
}
*strp = (char*)malloc(len + 1);
if (*strp == NULL) {
return -1;
}
len = vsnprintf(*strp, len + 1, fmt, ap_copy);
va_end(ap_copy);
return len;
}
int asprintf(char** ptr, const char* format, ...) {
va_list ap;
int ret;
*ptr = NULL;
va_start(ap, format);
ret = vasprintf(ptr, format, ap);
va_end(ap);
return ret;
}
#endifLogAppender
这个的话，这个类有很多种实现方法，具体的思路就是持有一个LogFormat，然后给它一个LogEvent，将生成出来的字符串加入到目的地，如文件或者控制台；
Logger
这个也非常好弄，他就是一个LogAppender的集合，将一个LogEvent分发给不同的LogAppender，实现一个信息分发到不同目的地；
End
也可以写一个Manger类，来管理所有的Logger，这个结构呢，就是怎么解析字符串，然后生成不同的item比较难，其他都是顺水推舟了；
Config系统：
使用了YAML-CPP库
Config系统的话，有3大类和两大操作：
ConfigVarBase、ConfigVar<T>:public ConfigVarBase、Config
两大操作：FormString、ToString
ConfigVarBase
ConfigVarBase就一个接口，没什么好说的，看代码：
class ConfigVarBase {
public:
using Ptr = std::shared_ptr<ConfigVarBase>;
ConfigVarBase(const std::string& name,const std::string& description = "")
:m_Name(name), m_Description(description) {
//To lower
std::transform(name.begin(), name.end(), m_Name.begin(), ::tolower);
}
virtual ~ConfigVarBase(){}
const std::string& GetName()const { return m_Name; };
const std::string& GetDescription()const {return m_Description;};
virtual std::string ToString() = 0;
virtual bool FromString(const std::string& val) = 0;
protected:
std::string m_Name;
std::string m_Description;
};
ConfigVar<T>
然后是ConfigVar<T>了，这个类的话，是一个模板，存储不同类型的信息，对应不同的配置需要，比如存储一个vector或者map。
我们会有一个ToString和FromString的操作，这俩呢，就是序列化和反序列话，将信息存储到文件中，然后从文件在加载信息，一段信息经过两次操作不能改变；
template<class T,
class FormSting_ = LexicalCast<std::string, T>,
class ToString_ = LexicalCast<T, std::string>>
class ConfigVar :public ConfigVarBase {
FormSting_ formStr;
ToString_ toStr;
public:
using Ptr = std::shared_ptr<ConfigVar<T>>;
ConfigVar(const std::string& name, const T& defaultVal, const std::string& description = "")
:ConfigVarBase(name, description), m_Val(defaultVal){}
std::string ToString() override {
try {
return toStr(m_Val);
}
catch (std::exception& e) {
LU_LOG_ERROR(LU_LOG_ROOT()) << "ConfigVar::ToString expection" <<
e.what() << " convert :" << typeid(m_Val).name() << " to string";
}
}
const T& GetValue() { return m_Val; }
static std::string GetTypeName() { return typeid(T).name(); }
virtual bool FromString(const std::string& val) override {
try {
m_Val = formStr(val);
return true;
}
catch (std::exception& e) {
LU_LOG_ERROR(LU_LOG_ROOT()) << "ConfigVar::ToString expection" <<
e.what() << " convert :" << "string to "<< typeid(m_Val).name();
return false;
}
}
private:
T m_Val;
};这边我们用LexicalCast将ToString和FormString分离到类外去操作，这样可以增加代码的可读性和可拓展性；
Config
这个类是最主要的一个类，作用是管理ConfigVar和读取文件，并根据读取的信息设置配置；
class Config {
public:
using Ptr = std::shared_ptr<Config>;
template<class T>
static typename ConfigVar<T>::Ptr LookUp(const std::string& name,
const T& defaultValue, const std::string& description) {
typename ConfigVar<T>::Ptr config = LookUp<T>(name);
if (config) {
return config;
}
if (name.find_first_not_of("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM._0123456789") != std::string::npos) {
LU_LOG_ERROR(LU_LOG_ROOT()) << "lookup name invaild :" << name;
throw std::invalid_argument(name);
}
typename ConfigVar<T>::Ptr v(new ConfigVar<T>(name, defaultValue, description));
map.emplace(name, v);
return std::dynamic_pointer_cast<ConfigVar<T>>(map.at(name));
}
template<class T>
static typename ConfigVar<T>::Ptr LookUp(const std::string& name) {
auto it = map.find(name);
if (it != map.end()) {
ConfigVar<T>::Ptr res = std::dynamic_pointer_cast<ConfigVar<T>>(it->second);
if (!res)
LU_LOG_ERROR(LU_LOG_ROOT()) << "Lookup name :" << name <<
" exist but type not is " << ConfigVar<T>::GetTypeName() << " " << it->second->ToString();
else
LU_LOG_INFO(LU_LOG_ROOT()) << "Lookup name :" << name << " exist";
return res;
}
LU_LOG_ERROR(LU_LOG_ROOT()) << "Lookup name :" << name << " not exist";
return nullptr;
}
static ConfigVarBase::Ptr LookupBase(const std::string& name);
static void LoadFormYaml(const YAML::Node& root);
private:
static std::unordered_map<std::string, ConfigVarBase::Ptr> map;
};这边的话主要是看LoadFormYaml这个方法，这个方法是接受一个Node节点，这个节点是存储被读取文件的整个信息，读取数据后根据数据设置map中的ConfigVar：
static void ListAllMember(const std::string& prefix,
const YAML::Node& node,
std::list<std::pair<std::string, const YAML::Node>>& output) {
if (prefix.find_first_not_of("qwertyuiopasdfghjklzxcvbnmQWERTYUIOPASDFGHJKLZXCVBNM._0123456789") != std::string::npos) {
LU_LOG_ERROR(LU_LOG_ROOT()) << "Congig invaild name " << prefix << " : " << node;
return;
}
/*
* Scalar是直接读取字符串形式的数据，
* 构建 x
* / \
* x.y x.z
* |
* x.y.u
*/
output.push_back({ prefix,node });
if (node.IsMap()) {
for (auto& t : node) {
ListAllMember(prefix.empty()?
t.first.Scalar() : prefix + "." + t.first.Scalar(),
t.second, output);
}
}
}
void Config::LoadFormYaml(const YAML::Node& root) {
std::list<std::pair<std::string, const YAML::Node>> allNodes;
ListAllMember("",root, allNodes);
for (auto& it : allNodes) {
std::string key = it.first;
if (key.empty())
continue;
std::transform(key.begin(), key.end(), key.begin(), ::tolower);
ConfigVarBase::Ptr var = LookupBase(key);
if (var) {
if (it.second.IsScalar()) {
var->FromString(it.second.Scalar());
}
else {
std::stringstream ss;
ss << it.second;
var->FromString(ss.str());
}
}
}
}主要是实现这两个函数，ListAllMember呢，是将root node中的所有节点都加入到一个list中，而且名字也有讲究，ConfigVar的name就root node展开的树中对应该ConfigVar节点的路径，路径名字的格式已经在代码中给出了，根据这个名字我们可以给每个ConfigVar设置数据；
