while(...) {
  *pos = ...;
  ++pos;
}

InputIterator pos, end;

while (pos != end) {
  ... // read-only access using *pos
  ++pos;
}

ForwardIterator pos1, pos2;

pos1 = pos2 = begin; /// both iterator refer to the same element
if(pos1 != end) {
  ++pos1; /// pos1 is one element ahead
  while(pos1 != end) {
    if(*pos1 == *pos2) {
      ... // precess adjacent duplicates
      ++pos1;
      ++pos2;
    }
  }
}

#include <iterator>
void advance(InputIterator& pos, Dist n)

/// 输入迭代器的情况
template <class _InIt, class _Diff>
inline void advance_impl(_InIt& _Where, _Diff _Off, std::input_iterator_tag) {
  /// 检查该偏移量不能为负值
  if (_Off < 0) {
    assert(false && "negative offset in advance");
  }
  /// 使用自增运算符来计算
  for (; 0 < _Off; --_Off) ++_Where;
}

/// 双向迭代器
template <class _BidIt, class _Diff>
inline void advance_impl(_BidIt& _Where, _Diff _Off,
                         std::bidirectional_iterator_tag) {
  /// 使用自增运算符来计算
  for (; 0 < _Off; --_Off) ++_Where;
  /// 如果偏移量为负值则使用自减运算符
  for (; _Off < 0; ++_Off) --_Where;
}

/// 随机访问迭代器
template <class _RanIt, class _Diff>
inline void advance_impl(_RanIt& _Where, _Diff _Off,
                         std::random_access_iterator_tag) {
  /// 使用operator += ，常量复杂度
  _Where += _Off;
}

template <class _InIt, class _Diff>
inline void advance(_InIt& _Where, _Diff _Off) {
  advance_impl(_Where, _Off,
               /// 在萃取迭代器的特性时去掉其const的属性来提高性能
               std::iterator_traits<_Iter>::iterator_category<
                   std::remove_const_t<_InIt>>());
}

#include <iterator>
ForwardIterator next(ForwardIterator pos)
ForwardIterator next(ForwardIterator pos, Dist n)

#include <iterator>
BidirectionalIterator prev(BidirectionalIterator pos)
BidirectionalIterator prev(BidirectionalIterator pos, Dist n)

template <class _InIt>
inline _InIt next(
    _InIt _First,
    std::iterator_traits<_InIt>::iterator_category<_InIt> _Off = 1) {
  static_assert(
      std::is_base_of<
          std::input_iterator_tag,
          typename std::iterator_traits<_InIt>::iterator_category>::value,
      "next requires input iterator");

  advance(_First, _Off);
  return (_First);
}

template <class _BidIt>
inline _BidIt prev(
    _BidIt _First,
    std::iterator_traits<_BidIt>::iterator_category<_BidIt> _Off = 1) {
  static_assert(
      std::is_base_of<
          std::bidirectional_iterator_tag,
          typename std::iterator_traits<_BidIt>::iterator_category>::value,
      "prev requires bidirectional iterator");

  advance(_First, -_Off);
  return (_First);
}

Dist distance(InputIterator pos1, InputIterator pos2)

template <typename it>
typename std::iterator_traits<it>::difference_type distance(it from, it to) {
  if constexpr (typename std::iterator_traits<it>::iterator_category() ==
                std::random_access_iterator_tag) {
    /// 随机访问迭代器
    return to - from;
  } else if constexpr (typename std::iterator_traits<it>::iterator_category() ==
                       std::input_iterator_tag) {
    /// input 迭代器
    typename std::iterator_traits<it>::difference_type res = 0;
    for (; from != to; ++from) {
      ++res;
    }
    return res;
  } else {
    static_assert("unknow iterator type.");
  }
}

#include <algorithm>
void iter_swap(ForwardIterator1 pos1, ForwardIterator pos2)

#include <array>
#include <iostream>
#include <tuple>
#include <utility>

template <typename T, T... ints>
void print_sequence(std::integer_sequence<T, ints...> int_seq) {
  std::cout << "" << int_seq.size() << ": ";
  ((std::cout << ints << ' '), ...);
  std::cout << '\n';
}

/// 转化数组为tuple
template <typename Array, std::size_t... I>
auto a2t_impl(const Array& a, std::index_sequence<I...>) {
  return std::make_tuple(a[I]...);
}

template <typename T, std::size_t N,
          typename Indices = std::make_index_sequence<N>>
auto a2t(const std::array<T, N>& a) {
  return a2t_impl(a, Indices{});
}

/// 漂亮地打印 tuple
template <class Ch, class Tr, class Tuple, std::size_t... Is>
void print_tuple_impl(std::basic_ostream<Ch, Tr>& os, const Tuple& t,
                      std::index_sequence<Is...>) {
  ((os << (Is == 0 ? "" : ", ") << std::get<Is>(t)), ...);
}

template <class Ch, class Tr, class... Args>
auto& operator<<(std::basic_ostream<Ch, Tr>& os, const std::tuple<Args...>& t) {
  os << "(";
  print_tuple_impl(os, t, std::index_sequence_for<Args...>{});
  return os << ")";
}

int main() {
  print_sequence(std::integer_sequence<unsigned, 9, 2, 5, 1, 9, 1, 6>{});
  print_sequence(std::make_integer_sequence<int, 20>{});
  print_sequence(std::make_index_sequence<10>{});
  print_sequence(std::index_sequence_for<float, std::iostream, char>{});

  std::array<int, 4> array = {1, 6, 3, 4};

  auto tuple = a2t(array);
  static_assert(std::is_same<decltype(tuple), std::tuple<int, int, int, int>>::value, "");

  std::cout << tuple <<'\n';
  system("pause");
}

class object{
  public:
  ~object() = default;
  static std::unique_ptr<object>& get_instance();
  private:
  object() = default; ///< 构造函数写为private，防止其他调用者单独构造该对象实例。
};

std::unique_ptr<object>& object::get_instance();
  static std::unique_ptr<object> instance;  ///< 该对象的唯一实例
  static std::once_flag flag; ///< 标志位, 标记只调用一次
  std::call_once(flag, [&](){
    instance = std::make_unique<object>();  ///< C++14以后版本的方法
    /*
    instance = std::unique_ptr<object>(new object()); ///< C++14 到 C++11 可用的方法
    */
  });
  return instance;
}

object* object::get_instance() {
  object* instance = nullptr;
  if(instance == nullptr) {
    instance = new object();
  }
  return instance;
}

object* object::get_instance(){
  static std::mutex mt;
  volatile object* instance = nullptr;  ///< volatile关键字为了防止编译器优化
  if(instance == nullptr) { ///< #1 读操作
    std::lock_guard<std::mutex> lock(mt);
    if(instance == nullptr) {
        instance = new object();  ///< #2 写操作
    }
  }
  return instance;
}

#include <iostream>

template <typename T>
class queue {
 public:
  queue(size_t size) : size_(size), front_(0), end_(0) { data_ = new T[size]; }
  ~queue() { delete[] data_; }
  queue(const queue& other) = delete;
  queue(queue&& other) = delete;
  queue operator=(const queue& other) = delete;
  queue operator=(queue&& other) = delete;

  bool is_empty() { return front_ == end_; }
  bool is_full() { return front_ = (end_ + 1) % size_; }

  const T& front() const { return data_[front_]; }

  void push(const T& val) {
    if ((end_ + 1) % size_ != front_) {
      data_[end_] = val;
      end_ = (end_ + 1) % size_;
    }
  }

  void pop() {
    if (front_ != end_) {
      front_ = (front_ + 1) % size_;
    }
  }

 private:
  size_t front_;
  size_t end_;
  size_t size_;
  T* data_;
};

int main() {
  queue<int> q(5);
  q.push(1);
  q.push(2);
  q.push(3);
  q.push(4);
  q.push(5);
  q.pop();
  q.pop();
  q.push(6);
  q.push(7);
  q.push(8);
  while (!q.is_empty()) {
    std::cout << q.front() << std::endl;
    q.pop();
  }
  return 0;
}

template <typename T>
class circular_q {
  size_t max_items_ = 0;
  typename std::vector<T>::size_type head_ = 0;
  typename std::vector<T>::size_type tail_ = 0;
  size_t overrun_counter_ = 0;
  std::vector<T> v_;

 public:
  using value_type = T;

  // empty ctor - create a disabled queue with no elements allocated at all
  circular_q() = default;

  explicit circular_q(size_t max_items)
      : max_items_(max_items + 1)  // one item is reserved as marker for full q
        ,
        v_(max_items_) {}

  circular_q(const circular_q &) = default;
  circular_q &operator=(const circular_q &) = default;

  // move cannot be default,
  // since we need to reset head_, tail_, etc to zero in the moved object
  circular_q(circular_q &&other) noexcept {
    copy_moveable(std::move(other));
  }

  circular_q &operator=(circular_q &&other) noexcept {
    copy_moveable(std::move(other));
    return *this;
  }

  // push back, overrun (oldest) item if no room left
  void push_back(T &&item) {
    if (max_items_ > 0) {
      v_[tail_] = std::move(item);
      tail_ = (tail_ + 1) % max_items_;

      if (tail_ == head_)  // overrun last item if full
      {
        head_ = (head_ + 1) % max_items_;
        ++overrun_counter_;
      }
    }
  }

  // Return reference to the front item.
  // If there are no elements in the container, the behavior is undefined.
  const T &front() const { return v_[head_]; }

  T &front() { return v_[head_]; }

  // Return number of elements actually stored
  size_t size() const {
    if (tail_ >= head_) {
      return tail_ - head_;
    } else {
      return max_items_ - (head_ - tail_);
    }
  }

  // Return const reference to item by index.
  // If index is out of range 0…size()-1, the behavior is undefined.
  const T &at(size_t i) const {
    assert(i < size());
    return v_[(head_ + i) % max_items_];
  }

  // Pop item from front.
  // If there are no elements in the container, the behavior is undefined.
  void pop_front() { head_ = (head_ + 1) % max_items_; }

  bool empty() const { return tail_ == head_; }

  bool full() const {
    // head is ahead of the tail by 1
    if (max_items_ > 0) {
      return ((tail_ + 1) % max_items_) == head_;
    }
    return false;
  }

  size_t overrun_counter() const { return overrun_counter_; }

 private:
  // copy from other&& and reset it to disabled state
  void copy_moveable(circular_q &&other) noexcept {
    max_items_ = other.max_items_;
    head_ = other.head_;
    tail_ = other.tail_;
    overrun_counter_ = other.overrun_counter_;
    v_ = std::move(other.v_);

    // put &&other in disabled, but valid state
    other.max_items_ = 0;
    other.head_ = other.tail_ = 0;
    other.overrun_counter_ = 0;
  }
};

#include <algorithm>
#include <atomic>
#include <cassert>
#include <iostream>
#include <map>
#include <mutex>
#include <vector>

class Container {
 public:
  Container() {
      std::lock_guard<std::mutex> lock(mut);
      auto it = uuid.load();
      uuid.store(++it);
      serial_number_ = it;
      container_map.insert({ serial_number_, this });
  }

  virtual int get_fluid_capacity() = 0;

  friend int totalFluidCapacity() {
    std::lock_guard<std::mutex> lock(mut);
    int result = 0;
    for (auto& it : container_map) {
      result += it.second->get_fluid_capacity();
    }
    return result;
  }

  friend Container* find_container(size_t serial_number) {
    std::lock_guard<std::mutex> lock(mut);
    if(container_map.find(serial_number) != container_map.end()) {
      return container_map[serial_number];
    } else {
      return nullptr;
    }
  }
  inline static std::mutex mut;
  inline static std::atomic<size_t> uuid;
  inline static std::map<size_t, Container*> container_map;

 protected:
  size_t serial_number_;
};

int totalFluidCapacity();
Container* find_container(size_t serial_number);

class Buckets : public Container {
  static constexpr double pi = 3.1415926;

 public:
  Buckets(int height, int radius) : height_(height), radius_(radius) {}
  virtual int get_fluid_capacity() override final {
    return static_cast<int>(radius_ * radius_ * height_ * pi);
  }

 private:
  int height_;
  int radius_;
};

class Boxes : public Container {
 public:
  enum class material_type : int {
    m = 0,  /// for metal
    c = 1,  /// for cardboard
  };

  Boxes(const int length, const int width, const int height, material_type type)
      : length_(length), width_(width), height_(height), type_(type) {}
  virtual int get_fluid_capacity() override final {
    if (type_ == material_type::c) {
      return length_ * width_ * height_;
    } else {
      return 0;
    }
  }

 private:
  int length_;
  int width_;
  int height_;
  material_type type_;
};

int main() {
  Boxes box_c(1, 1, 1, Boxes::material_type::c);
  Boxes box_m(1, 1, 1, Boxes::material_type::m);

  Buckets bucket(1, 1);

  auto capa = totalFluidCapacity();
  assert(capa == 4);

  auto p_container = find_container(2);
  assert(p_container == & box_m);
  return 0;
}

struct TreeNode {
  int val;
  TreeNode* left;
  TreeNode* right;
  TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

inline std::string serialize(TreeNode* root) {
  if (root == nullptr) {
    return "null";
  }
  std::vector<TreeNode*> queue;
  std::vector<std::vector<std::string>> result;
  queue.push_back(root);
  int height = 0;
  while (!queue.empty() &&
    !std::all_of(queue.begin(), queue.end(),
      [](const TreeNode* node) { return node == nullptr; })) {
    std::vector<std::string> temp;
    int count = static_cast<int>(std::pow(2, height));
    while (count-- != 0) {
      auto front = queue.front();
      queue.erase(queue.begin());
      if (front == nullptr) {
        temp.push_back("null");
        queue.push_back(nullptr);
        queue.push_back(nullptr);
      }
      else {
        temp.push_back(std::to_string(front->val));
        queue.push_back(front->left);
        queue.push_back(front->right);
      }
    }
    result.push_back(temp);
    ++height;
  }

  std::string str = "[";
  /// 组装字符串
  for (auto& it : result) {
    for (auto& it1 : it) {
      str += it1 + ",";
    }
  }
  if (str.back() == ',') {
    str.erase(std::prev(str.end()));
    str += "]";
  }
  return str;
}

inline void split(const std::string& s, std::vector<std::string>& tokens,
  const std::string& delimiters = " ") {
  std::string::size_type lastPos = s.find_first_not_of(delimiters, 0);
  std::string::size_type pos = s.find_first_of(delimiters, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delimiters, pos);
    pos = s.find_first_of(delimiters, lastPos);
  }
}
// Decodes your encoded data to tree.
inline TreeNode* deserialize(std::string data) {
  if (data.front() != '[' || data.back() != ']') {
    return nullptr;
  }
  data.erase(data.begin());
  data.erase(std::prev(data.end()));
  std::vector<std::string> vec_str;
  split(data, vec_str, ",");
  if (vec_str.empty() || vec_str.front() == "null") {
    return nullptr;
  }

  std::vector<TreeNode*> result;
  for (const auto& it : vec_str) {
    if (it == "null") {
      result.push_back(nullptr);
    }
    else {
      result.push_back(new TreeNode(std::stoi(it)));
    }
  }

  for (size_t i = 0; i < result.size(); ++i) {
    if(result.at(i) != nullptr){
      if (result.size() > i * 2 + 2) {
      result.at(i)->left = result.at(i*2+1);
      result.at(i)->right = result.at(i*2+2);
      }
    }
  }

  return result.at(0);
}

#include <cassert>

int main(){

  auto result = deserialize("[5,null,7,null,null,6,8]");
  assert(serialize(result) == "[5,null,7,null,null,6,8]");

  auto string =
      "[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,"
      "27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,"
      "51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,"
      "75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,"
      "99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,"
      "117,118,119,120,121,122,123,124,125,126]";
  auto result3 = deserialize(string);
  assert(serialize(result3) == string);
}

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Codec {
 public:
  // Encodes a tree to a single string.
  string serialize(TreeNode* root) {
    std::string res = "[";
    std::queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
      auto temp = q.front();
      q.pop();
      if (temp == nullptr) {
        res += "null,";
      } else {
        res += std::to_string(temp->val) + ",";
        q.push(temp->left);
        q.push(temp->right);
      }
    }
    res += "]";
    return res;
  }

  // Decodes your encoded data to tree.
  TreeNode* deserialize(string data) {
    /// 去除首尾的'[]'
    data.erase(data.begin());
    data.erase(std::prev(data.end()));
    /// 把字符串解析成数组
    auto begin = 0;
    auto lastPos = data.find_first_not_of(',', 0);
    auto pos = data.find_first_of(',', lastPos);
    std::queue<std::string> q;
    while (pos != std::string::npos || std::string::npos != lastPos) {
      q.push(data.substr(lastPos, pos - lastPos));
      lastPos = data.find_first_not_of(',', pos);
      pos = data.find_first_of(',', lastPos);
    }
    /// 遍历数组建立树
    auto head = q.front();
    std::queue<TreeNode*> q_ceng;
    std::queue<TreeNode*> q_next_ceng;
    TreeNode* r = nullptr;
    if (head != "null") {
      auto thead = new TreeNode(std::atoi(head.c_str()));
      q_ceng.push(thead);
      r = thead;
    }
    q.pop();
    while (!q.empty()) {
      while (!q_ceng.empty()) {
        auto t = q_ceng.front();
        q_ceng.pop();
        auto l_t = q.front();
        q.pop();
        auto r_t = q.front();
        q.pop();
        if (l_t != "null") {
          t->left = new TreeNode(std::atoi(l_t.c_str()));
          q_next_ceng.push(t->left);
        }
        if (r_t != "null") {
          t->right = new TreeNode(std::atoi(r_t.c_str()));
          q_next_ceng.push(t->right);
        }
      }
      while (!q_next_ceng.empty()) {
        q_ceng.push(q_next_ceng.front());
        q_next_ceng.pop();
      }
    }
    return r;
  }
};

#include <iostream>
#include <map>
#include <string>
#include <vector>

/**
 * @brief           把字符串前后的字符串给去除
 * @param           s       [in]    要剪切的字符串
 * @param           chars   [in]    要去除什么的字符串
 * @return          std::string& 剪切后的字符串
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @note
 */
static std::string& strip(std::string& s, const std::string& chars = " ") {
  s.erase(0, s.find_first_not_of(chars.c_str()));
  s.erase(s.find_last_not_of(chars.c_str()) + 1);
  return s;
}

/**
 * @brief           以特定符号为分隔符，切分字符串并放入vector里
 * @param           s           [in]    原字符串
 * @param           tokens      [out]   剪切后的子字符串
 * @param           delimiters  [in]    分隔符
 * @author          lijiancong(lijiancong@gbcom.com.cn)
 * @note
 */
static void split(const std::string& s, std::vector<std::string>& tokens,
                  const std::string& delimiters = " ") {
  std::string::size_type lastPos = s.find_first_not_of(delimiters, 0);
  std::string::size_type pos = s.find_first_of(delimiters, lastPos);
  while (std::string::npos != pos || std::string::npos != lastPos) {
    tokens.push_back(s.substr(lastPos, pos - lastPos));
    lastPos = s.find_first_not_of(delimiters, pos);
    pos = s.find_first_of(delimiters, lastPos);
  }
}

static void parse(std::string& s, std::map<std::string, std::string>& items) {
  std::vector<std::string> elements;
  s.erase(0, s.find_first_not_of(" {"));
  s.erase(s.find_last_not_of("} ") + 1);
  split(s, elements, ",");
  for (auto& iter : elements) {
    std::vector<std::string> kv;
    split(iter, kv, ":");
    if (kv.size() != 2) continue;
    items[strip(kv[0], " \"")] = strip(kv[1], " \"");
  }
}

int main() {
  std::string data =
      "  {  \"key1\"  :  \"data1\"  ,  \"key2\"  :  \"data2\"    }  ";
  std::map<std::string, std::string> items;
  parse(data, items);

  for (const auto& iter:items){
    std::cout << "key=" << iter.first << ",value=" << iter.second << std::endl;
  }
  system("pause");
}

//
// Rotating file sink based on size
//
template<typename Mutex>
class rotating_file_sink final : public base_sink<Mutex>
{
public:
    rotating_file_sink(filename_t base_filename, std::size_t max_size, std::size_t max_files, bool rotate_on_open = false);
    static filename_t calc_filename(const filename_t &filename, std::size_t index);
    filename_t filename();

protected:
    void sink_it_(const details::log_msg &msg) override;
    void flush_() override;

private:
    // Rotate files:
    // log.txt -> log.1.txt
    // log.1.txt -> log.2.txt
    // log.2.txt -> log.3.txt
    // log.3.txt -> delete
    void rotate_();

    // delete the target if exists, and rename the src file  to target
    // return true on success, false otherwise.
    bool rename_file_(const filename_t &src_filename, const filename_t &target_filename);

    filename_t base_filename_;          ///< 基础文件名称
    std::size_t max_size_;              ///< 最大单个文件大小
    std::size_t max_files_;             ///< 最大日志文件数量
    std::size_t current_size_;          ///< 当前文件的大小
    details::file_helper file_helper_;  ///< 用于辅助写文件的对象
};

/// @name     rotating_file_sink
/// @brief    构造本对象，
///           1. 打开日志文件
///           2. 获取当前文件大小
///           3. 如果超出了单个文件大小，则重新创建文件并打开
///
/// @param    base_filename   [in]  基础的文件名
/// @param    max_size        [in]  最大单个文件大小
/// @param    max_files       [in]  最大的文件
/// @param    rotate_on_open  [in]  是否在文件打开时rotate
///
/// @date     2020-07-04 21:51:27
rotating_file_sink(std::string base_filename, std::size_t max_size,
                   std::size_t max_files, bool rotate_on_open = false)
    : base_filename_(std::move(base_filename)),
      max_size_(max_size),
      max_files_(max_files) {
  /// 打开当前应该写入的文件，并由file_helper对象来持有这个文件指针
  file_helper_.open(calc_filename(base_filename_, 0));
  /// 该函数时间执行时间很长，在这里只执行一次。
  current_size_ = file_helper_.size();
  /// 假如允许rotate且当前文件大小大于零
  if (rotate_on_open && current_size_ > 0) {
    /// 执行一次rotate
    rotate_();
  }
}

/// @name     rotate_
/// @brief    执行循环日志文件的创建
/// @details
/// Rotate files:
/// log.txt -> log.1.txt
/// log.1.txt -> log.2.txt
/// log.2.txt -> log.3.txt
/// log.3.txt -> delete
///
/// @param    NONE
///
/// @return   NONE
///
/// @date     2020-07-04 21:58:24
inline void rotate_() {
  /// 首先关闭该文件
  file_helper_.close();
  /// 开始查找要创建的下一个日志文件名称
  for (auto i = max_files_; i > 0; --i) {
    /// 拼装出上一个该文件名称
    std::string src = calc_filename(base_filename_, i - 1);
    if (!path_exists(src)) {
      /// 该文件如果不存在则到下一个循环
      continue;
    }
    /// 这里找到要创建的日志名称了日志文件的名称
    std::string target = calc_filename(base_filename_, i);

    /// 把上一个文件改名为当前的文件名
    if (!rename_file_(src, target)) {
      /// 如果失败则在一个短暂的延迟后再次尝试
      sleep_for_millis(100);
      if (!rename_file_(src, target)) {
        /// 关闭并打开这个日志文件，防止它增长超出限制
        file_helper_.reopen(true);
        current_size_ = 0;
        /// 抛出异常
        throw("rotating_file_sink: failed renaming ");
      }
    }
  }
  /// 以追加模式("a")重新打开这个文件
  file_helper_.reopen(true);
}

/// @name   sink_it_
/// @brief  写文件日志的函数，如果写入日志大于最大文件大小则创建下一个文件
///
/// @param  msg [in]  写入的日志信息
///
/// @return
///
/// @date     2020-07-05 09:33:12
void sink_it_(const details::log_msg &msg) override {
  std::string formatted;
  /// 拼装日志信息
  base_sink<Mutex>::formatter_->format(msg, formatted);
  /// 计算这条日志加上原本大小是否超过了最大文件大小
  current_size_ += formatted.size();
  if (current_size_ > max_size_) {
    /// 超过了就创建下一个文件
    rotate_();
    /// 更新为当前文件大小为这个日志信息的大小
    current_size_ = formatted.size();
  }
  /// 如果没有超过最大大小则继续写该文件
  file_helper_.write(formatted);
}

/// @name     flush_
/// @brief    刷新文件
///
/// @param    NONE
///
/// @return   NONE
///
/// @date     2020-07-05 09:36:23
void flush_() override { file_helper_.flush(); }

template <typename T>
Blob<T>::Blob(std::initializer_list<T> il)
try
 : data(std::make_shared<std::vector<T>>(il))
{/** ... */}
catch (const std::bad_alloc &e)
{
    handle_out_of_memory(e);
}

void recoup() noexcept; /** 不会抛出异常 */
void alloc();           /** 可能会抛出异常 */

void recoup() noexcept(true);	/** 不会抛出异常 */
void alloc() noexcept(false);	/** 可能抛出异常 */

noexcept(recoup())	/** 如果recoup不跑出异常则结果为true；否则结果为false */
noexcept(e)	/** 等价于上一句 */

void f() noexcept(noexcept(g()));	// f 和 g的异常说明一致